two classes within a class - c++

Question

What is a better way to implement this in C++ (without if-else). In C I can initialize function pointer, and then just call function pointers. So if you look at class C, some objects of class C use only class A and some class B. I am more familiar with C than C++.
class A {
public:
int func1();
int func2();
int func3();
};
class B:A {
public:
int func1() {x=1; A::func1();}
int func2() {A::func2(); x=1;}
int func3() {x=1; A::func2();}
};
class C {
public:
C::C(bool class_a) {_class_a = _class_a;}
void func_c_1()
{
if(_class_a) a.func1();
else b.func1();
}
void func_c_2()
{
if(_class_a) a.func2();
else b.func2();
}
void func_c_3()
{
if(_class_a) a.func3();
else b.func3();
}
private:
bool _class_a;
A a;
B b;
};

Answer 1

Your code doesn't compile and I could be misunderstanding you completely but if you want a class which does different stuff depending on how it was created you might be helped by using a virtual base with pure virtual functions and deriving A and B from it overriding those virtual functions.
class Base
{
public:
virtual int func1() = 0;
virtual int func2() = 0;
virtual int func3() = 0;
virtual ~Base(){} //it is important that this is virtual
};
class A: public Base
{
public:
virtual int func1(){
//do something
}
virtual int func2(){
//do something
}
virtual int func3(){
//do something
}
};
class B: public A
{
public:
virtual int func1(){
//do something else
((A*)this)->func1(); //call A's func1()
}
virtual int func2(){
//do something else
}
virtual int func3(){
//do something else
}
};
Base *a = new A;
Base *b = new B;
Base *c = a;
c->func1(); //does something
c=b;
c->func1(); //does something else
Otherwise if you essentially want two different classes (with distinct types) you could use a template. If this is what you want comment and I will add example code.
It also should be noted that nothing is stopping you from using function pointers in C++ although I wouldn't recommend it. Here is an example code just for giggles:
#include <functional>
class A
{
public:
int func1(){
//do something
return 1;
}
int func2(){
//do something
return 1;
}
int func3(){
//do something
return 1;
}
};
class B
{
public:
int func1(){
//do something else
return 1;
}
int func2(){
//do something else
return 1;
}
int func3(){
//do something else
return 1;
}
};
class C
{
public:
C(bool useA)
{
if(useA) {
func1 = std::bind(&A::func1,a_);
func2 = std::bind(&A::func2,a_);
func3 = std::bind(&A::func3,a_);
}
else {
func1 = std::bind(&B::func1,b_);
func2 = std::bind(&B::func2,b_);
func3 = std::bind(&B::func3,b_);
}
}
std::function<int()> func1;
std::function<int()> func2;
std::function<int()> func3;
private:
A a_;
B b_;
};
C c(true);
C c2(false);
c.func1();

Answer 2

It looks to me like you're trying to understand inheritance in C++. Your code looks like it's trying to get different behavior depending on if you tell it to be a class A or a class B. If so, this should help:
#include <iostream>
using namespace std;
class A
{
public:
void foo() { cout << "A::foo\n"; }
void bar() { cout << "A::bar\n"; }
};
class B : public A
{
public:
void foo() { cout << "B::foo\n"; }
void fee() { cout << "B::fee\n"; }
};
main()
{
A* a = new A();
B* b = new B();
a->foo();
a->bar();
b->foo();
b->bar();
b->fee();
((a)b)->foo();
((a)b)->bar();
}
I make class A, and (publicly) make class B inherit from it. Within main, the first 5 lines show behavior you'd expect, but if you want the b object to act as an A, I just cast it to it, and it does. (If you run this code, you'll see that the final foo line emits A::foo.)
So the behavior is not forced at construction time. When you construct the object, B::foo overrides A::foo. But simply by casting to the superclass, you can access the original functions.
Note, if you want b.foo() to always emit "B::foo", set the foo function in A to virtual:
class A
{
public:
virtual void foo() { cout << "A::foo\n"; }
void bar() { cout << "A::bar\n"; }
virtual ~foo() { /* any destructor code for the base class */ }
};
In this case, whether you use b->foo() or ((A*)b)->foo(), the output will be "B::foo". The run time will work with the original type of the object, instead of with the type you cast it to. Important - As soon as you make any virtual function in your class, you must make a virtual destructor for that function. If you don't, only the base class's destructor will be called when your object is deleted. (When you use virtual destructors, each destructor is called from the most-derived class to the base, essentially unwinding the work that was done when the object was constructed.)
Hope this helps...