C++/inheritance and virtual functions

#include <iostream>
#include <string>
using namespace std;
 
/* --- */
 
class c1_i {
	public:
		explicit c1_i(void);
		~c1_i(void);
 
		virtual void c1_callback(void) = 0;
};
 
c1_i::c1_i(void) {
	cout << "c1_i::c1_i\n";
}
c1_i::~c1_i(void) {
	cout << "c1_i::~c1_i\n";
}
 
/* --- */
 
/* c2_i has no constructor / destructor functions */
class c2_i {
	public:
		virtual void c2_callback(void) = 0;
};
 
/* --- */
 
 /* c3_i has a constructor that takes an argument */
class c3_i {
	public:
		explicit c3_i(string message);
 
		string message;
 
		virtual void c3_callback(void) = 0;
};
 
c3_i::c3_i(string message) {
	this->message = message;
}
 
/* --- */
 
class myC: public c1_i, public c2_i, public c3_i {
	public:
		explicit myC(string message);
		~myC(void);
 
		void c1_callback(void);
		void c2_callback(void);
		void c3_callback(void);
};
 
myC::myC(string message): c3_i(message) {
	cout << "myC::myC\n";
}
myC::~myC(void) {
	cout << "myC::~myC\n";
}
void myC::c1_callback(void) {
	cout << "myC::c1_callback\n";
}
void myC::c2_callback(void) {
	cout << "myC::c2_callback\n";
}
void myC::c3_callback(void) {
	cout << "myC::c3_callback: " << message << "\n";
}
 
/* --- */
 
class t1 {
	public:
		explicit t1(c1_i *i);
		~t1(void);
 
		void exec(void);
 
	private:
		c1_i *i;
};
t1::t1(c1_i *i) {
	if (i == NULL) throw(-1);
	this->i = i;
	cout << "t1::~t1\n";
}
t1::~t1(void) {
	cout << "t1::~t1\n";
}
void t1::exec(void) {
	cout << "t1::exec\n";
	i->c1_callback();
}
 
/* --- */
 
class t2 {
	public:
		explicit t2(c2_i *i);
		~t2(void);
 
		void exec(void);
 
	private:
		c2_i *i;
};
t2::t2(c2_i *i) {
	if (i == NULL) throw(-1);
	this->i = i;
	cout << "t2::~t2\n";
}
t2::~t2(void) {
	cout << "t2::~t2\n";
}
void t2::exec(void) {
	cout << "t2::exec\n";
	i->c2_callback();
}
 
/* --- */
 
int main(int argc, char *argv[]) {
	myC m("howdy");
 
	m.c1_callback();
	m.c2_callback();
	m.c3_callback();
 
	t1 t(&m);
	t.exec();
 
	t2 tt(&m);
	tt.exec();
 
	cout << "hi\n";
	return 0;
}