why seeples no interfaces?


#include<iostream>

using namespace std;

class A {
public:

  A() {
  }

  virtual ~A() {
  }

  void waka() {
    cout << "WakA!";
  }

};


class IWoopaWaka {
public:
  IWoopaWaka() {
  }

  virtual ~IWoopaWaka() {
  }

  virtual void waka() = 0;
  virtual void woopa() = 0;
};

class B : public IWoopaWaka, public A {
public:
  B() : A() {
  }

  virtual ~B() {
  }

  void woopa() {
    cout << "Woooopa!";
  }
};


int main(int argc, char** argv) {
  IWoopaWaka* wapa = new B();
  wapa->waka();
  wapa->woopa();
  delete wapa;
  return 0;
}

$g++ m.cpp
m.cpp: In function ‘int main(int, char**)’:
m.cpp:49: error: cannot allocate an object of abstract type ‘B’
m.cpp:34: note:   because the following virtual functions are pure within ‘B’:
m.cpp:30: note:         virtual void IWoopaWaka::waka()

#include<iostream>

using namespace std;

class A {
public:

  A() {
  }

  virtual ~A() {
  }

  void waka() {
    cout << "WakA!";
  }

};


class IWoopaWaka {
public:
  IWoopaWaka() {
  }

  virtual ~IWoopaWaka() {
  }

  virtual void waka() = 0;
  virtual void woopa() = 0;
};

class B : public IWoopaWaka, public A {
public:
  B() : A() {
  }

  virtual ~B() {
  }

  void waka() {
    A::waka();
  }

  void woopa() {
    cout << "Woooopa!";
  }
};


int main(int argc, char** argv) {
  IWoopaWaka* wapa = new B();
  wapa->waka();
  wapa->woopa();
  delete wapa;
  return 0;
}

$g++ m.cpp
$a.out
WakA!Woooopa!$

>>8
but..buta..seeples no has no replacement for interfaces. There seems to be no way. Can you do it the better way in seeples? I was actually going to ask if anyone knew of a less archaic method than:


#include<iostream>

using namespace std;

class A {
public:
  virtual ~A() {}

  void waka1() { cout << "WakA1!"; }
  void waka2() { cout << "WakA2!"; }
  void waka3() { cout << "WakA3!"; }
  void waka4() { cout << "WakA4!"; }
  void waka5() { cout << "WakA5!"; }
  void waka6() { cout << "WakA6!"; }
  void waka7() { cout << "WakA7!"; }
  void waka8() { cout << "WakA8!"; }
};


class IWoopaWaka {
public:
  virtual ~IWoopaWaka() {}
  virtual void waka1() = 0;
  virtual void waka2() = 0;
  virtual void waka3() = 0;
  virtual void waka4() = 0;
  virtual void waka5() = 0;
  virtual void waka6() = 0;
  virtual void waka7() = 0;
  virtual void waka8() = 0;
  virtual void woopa() = 0;
};

class B : public A, public IWoopaWaka {
public:
  B() : A() { }

  virtual ~B() {}

  void woopa() { cout << "Woooopa!"; }
};


int main(int argc, char** argv) {
  IWoopaWaka* wapa = new B();
  wapa->waka1();
  wapa->waka2();
  wapa->waka3();
  wapa->waka4();
  wapa->waka5();
  wapa->waka6();
  wapa->waka7();
  wapa->waka8();
  wapa->woopa();
  delete wapa;
  return 0;
}

$g++ m.cpp
m.cpp: In function ‘int main(int, char**)’:
m.cpp:46: error: cannot allocate an object of abstract type ‘B’
m.cpp:35: note:   because the following virtual functions are pure within ‘B’:
m.cpp:24: note:         virtual void IWoopaWaka::waka1()
m.cpp:25: note:         virtual void IWoopaWaka::waka2()
m.cpp:26: note:         virtual void IWoopaWaka::waka3()
m.cpp:27: note:         virtual void IWoopaWaka::waka4()
m.cpp:28: note:         virtual void IWoopaWaka::waka5()
m.cpp:29: note:         virtual void IWoopaWaka::waka6()
m.cpp:30: note:         virtual void IWoopaWaka::waka7()
m.cpp:31: note:         virtual void IWoopaWaka::waka8()

#include<iostream>

using namespace std;

class A {
public:
  virtual ~A() {}

  void waka1() { cout << "WakA1!"; }
  void waka2() { cout << "WakA2!"; }
  void waka3() { cout << "WakA3!"; }
  void waka4() { cout << "WakA4!"; }
  void waka5() { cout << "WakA5!"; }
  void waka6() { cout << "WakA6!"; }
  void waka7() { cout << "WakA7!"; }
  void waka8() { cout << "WakA8!"; }
};


class IWoopaWaka {
public:
  virtual ~IWoopaWaka() {}
  virtual void waka1() = 0;
  virtual void waka2() = 0;
  virtual void waka3() = 0;
  virtual void waka4() = 0;
  virtual void waka5() = 0;
  virtual void waka6() = 0;
  virtual void waka7() = 0;
  virtual void waka8() = 0;
  virtual void woopa() = 0;
};

class B : public A, public IWoopaWaka {
public:
  B() : A() { }

  virtual ~B() {}

  void woopa() { cout << "Woooopa!"; }

  void waka1() { A::waka1(); }
  void waka2() { A::waka2(); }
  void waka3() { A::waka3(); }
  void waka4() { A::waka4(); }
  void waka5() { A::waka5(); }
  void waka6() { A::waka6(); }
  void waka7() { A::waka7(); }
  void waka8() { A::waka8(); }
};

int main(int argc, char** argv) {
  IWoopaWaka* wapa = new B();
  wapa->waka1();
  wapa->waka2();
  wapa->waka3();
  wapa->waka4();
  wapa->waka5();
  wapa->waka6();
  wapa->waka7();
  wapa->waka8();
  wapa->woopa();
  delete wapa;
  return 0;
}

$g++ m.cpp
$a.out
WakA1!WakA2!WakA3!WakA4!WakA5!WakA6!WakA7!WakA8!Woooopa!

Seeples can't seem to choose the non pure virtual method when resolving ambiguous method calls. For some reason, it still tries to call the pure virtual one when a real method is available. y u do this seeples? y u make me reimplement all doos methods and make em call the non virtual method. y u do dis to me?