Is there a way to provide constructor parameters to a base class when new-ing a derived class instance? (That is, when the base class constructor has default values for these parameters)
E.g.
class Base
{
public:
Base::Base( string name = "" )
: m_name( name ) {};
private
string m_name;
};
class Derived : public Base
{
public:
Derived::Derived() {};
};
Then I need to do something like this:
void main()
{
Base* instance = new Derived( "Jeff" );
};
This obviously doesn't work. Is there a way to new a derived instance and provide a constructor parameter to it's base without having to provide that parameter in the derived class constructor.
Is there a way to new a derived instance and provide a constructor parameter to it's base without having to provide that parameter in the derived class constructor.
No.
Your derived-class constructor needs to take the arguments, and explicitly pass them down to the base-class constructor.
class Derived : public Base
{
public:
Derived::Derived(string name) : Base(name) {};
};
This is the case regardless of whether you're using new or not.
You can't do it if you want distinct names into base class. however distinct name is not a criteria, you can do it using passing constant literals as:
class Base
{
public:
Base::Base( string name = "" )
: m_name( name ) {};
private
string m_name;
};
class Derived : public Base
{
public:
Derived::Derived() : Base ("Jeff") {};
Derived::Derived(string &name) : Base (name) {};
};
OR pass default value to Derived class constructor.
class Derived : public Base
{
public:
Derived::Derived(string name = "Jeff") : Base (name) {};
};
Related
Is it possible to design a class that will inherit from any one of a group of base classes? I would like to be able to write something like:
class Derived : public ArbitraryBase {
public:
Derived () : ArbitraryBase () {}
...
};
where ArbitraryBase can be some base class determined at compile time. I have a group of base classes that I would like to derive identical classes from. Is there a way to avoid writing an individual derived class for each of the base classes?
If it is truly determined at compile time, you can make your derived class a template:
template<class T>
class Derived : public T {
public:
Derived() {}
...
};
You can later create instantiate this class by providing the base type:
int main() {
Derived< ??? > my_object;
...
}
Where ??? is some compile time way of getting your derived type.
You can do this via a template. Using
template<typename T>
class Derived : public T
{
public:
Derived() : T() {}
// or just use if actually need to provide a default constructor
Derived() = default;
};
gives you a class that inherits from T and calls T's default constructor. You would create a concrete class with it like
Derived<Base1> d;
and now d is a Derived that inherits from Base1.
If you need to inherit from an arbitrary number of bases then you can use a variadic template like
template<typename... Bases>
class Derived : public Bases...
{
public:
Dervied() : Bases()... {}
// or just use if actually need to provide a default constructor
Derived() = default;
};
and it would be used like
Derived<Base1, Base2, ..., BaseN> d;
I have the following class hierarchy, where the Base class depends on its derived class to supply it an argument in its constructor:
class Member
{
public:
Member(int v);
};
class Base
{
public:
Base(const Member& m);
};
class Derived : public Base
{
public:
Derived() : m_(123), Base(m_) // <- here is the problem
{
}
private:
Member m_;
};
The problem is, though, that in Derived's constructor, the Base constructor gets called first, when Derived's member variable m_ which it depends on isn't initialized yet.
Is there a way to force the compiler to call the constructor of m_ first or should I just rework my class hierarchy?
You can simulate initializing your member before the base class by making it it's own base class which you initialize first. You can wrap it in a simple class type and have Derived inherit privately from that type before Base. In the following example, Derived has a Member _m; which is initialized and then used to initialize Base.
class Member
{
public:
Member(int) {}
};
class Base
{
public:
Base(const Member&) {}
};
// The new wrapper
struct member_wrapper
{
member_wrapper(int v) : m_(v) {}
Member m_;
};
class Derived : private member_wrapper, public Base
{
public:
Derived() : member_wrapper(123), Base(m_)
{ }
};
Though in this case, since m_ is already a class type and Derived has no other members with that type, you can just inherit privately from Member directly. If you had a non-class type or multiple members of the same type that needed to be initialized before Base you would need to wrap them.
class Member
{
public:
Member(int) {}
};
class Base
{
public:
Base(const Member&) {}
};
class Derived : private Member, public Base
{
public:
Derived() : Member(123), Base(*this)
{ }
};
Consider a base class that has an attribute
class Base
{
protected:
AttributeBase * elementPtr;
...
};
And a derived class
class Derived : public Base
{
...
};
Also I have a class AttributeDerived which derives from AttributeBase
When I create an object of the class Base I would like elementPtr to be initialized in this way:
elementPtr = new AttributeBase()
But when I create an object of the class Derived I would like elementPtr to be initialized in this way:
elementPtr = new AttributeDerived()
What is the cleanest way to do that?
You could add a protected constructor to Base which allows the derived class to pass an elementPtr to use:
Base (AttributeBase* elementPtr) : elementPtr(elementPtr)
{}
Then in your derived class, call that constructor:
Derived() : Base(new AttributeDerived())
{}
If you use C++11, you could then have other Base constructors delegate to the protected one to limit code duplication.
You could add different ctors of Base for different purpose:
class Base
{
protected:
AttributeBase * elementPtr;
Base(AttributeBase * p) : elementPtr(p) {}
public:
Base() : elementPtr(new AttributeBase) {}
};
class Derived : public Base
{
public:
Derived() : Base(new AttributeDerived) {}
};
And then
Base b; // elementPtr = new AttributeBase()
Derived d; // elementPtr = new AttributeDerived()
I have the following class:
class Base {
public:
Base(string name) {
agg = new Aggregate(name);
}
private:
Aggregate* agg;
};
Now I need to extend this class:
class Derived : Base {
public:
Derived(string name) : Base(name) {
agg2 = new Aggregate2(name);
}
private:
Aggregate2* agg2;
};
What I want is when I create a Base object, Aggregate needs to be created and when I create a Derived object only Aggregate2 should be created.
Now this is not happening because Aggregate its created inside the constructor which is called when I create a Derived object and like this Aggregate and Aggregate2 would be created.
I could move the creation to a different method and call that after creating the object.
Is there any other elegant way to do what I want ?
You may use the following:
class Base {
public:
explicit Base(string name) : agg(new Aggregate(name)) {}
protected:
Base() = default;
private:
std::unique_ptr<Aggregate> agg;
};
class Derived : Base {
public:
// implicit call to Base(), you may be explicit if you want
Derived(string name) : agg2(new Aggregate2(name)) {}
private:
std::unique_ptr<Aggregate2> agg2;
};
This is something you shouldn't do. If your second class isn't supposed to have the first Aggregate member, then the right way is to make two separate classes and not to use inheritance:
class Foo1 { ... };
class Foo2 { ... };
Now if you really have a reason to use inheritance you have a few options:
- Use a base class from which both Foo1 and Foo2 will derive. The base class only contains what is common to both Foo1 and Foo2. The Aggregates you need go separately into Foo1 and Foo2. (recommended)
- Let Foo1 have a union member (if you know the whys and wherefores of unions):
union Bla { std::unique_ptr<Agg1> a1; std::unique_ptr<Agg2> a2; };
And I should strongly emphasize that I can hardly think of an example where the second version is meaningful... Go for a separate base class!
Try this code
class Base {
public:
Base() { }
Base(string name) {
agg = new Aggregate(name);
}
void setName(string name) {
agg = new Aggregate(name);
}
private:
Aggregate* agg;
};
class Derived : Base {
public:
Derived(string name) {
agg2 = new Aggregate2(name);
}
private:
Aggregate2* agg2;
};
You can have a string type data member in Base class; which can be assigned value (same as name,in constructor) and you can access it in derived also(make it protected) to initialize agg2 in Derived class.
I would use a constructor overload for this:
class Base {
public:
Base(string name) : agg(new Aggregate(name)) {}
protected:
Base(Aggregate* agg) : agg(agg) {} //Base will take possession of the passed pointer.
private:
std::unique_ptr<Aggregate> agg;
};
class Derived : Base {
public:
Derived(string name) : Base(new Aggregate2(name)) {}
};
Note:
This assumes that Aggregate2 is derived from Aggregate. This assumption is based on the fact that removing ability of a base class in a derived class is at least a very strong code smell. So I concluded that both aggregates basically serve the same function, so that the second variable to hold the Aggregate2 instance is superfluous, and that Aggregate2 is a subclass of Aggregate to match behavior with relation.
Instead of this:
class base
{
protected:
base( int value )
: member{value}
{}
int member = 0;
};
class derived_1 : public base
{
public:
derived_1()
: base{ 1 }
{}
};
class derived_2 : public base
{
public:
derived_2()
: base{ 2 }
{}
};
This would be useful:
class base
{
protected:
int member = 0; // Default value
};
class derived_1 : public base
{
base::member = 1; // Instead of passing it to a base class constructor
};
class derived_2 : public base
{
base::member = 2;
};
Will c++1y support this, or similar, syntax?
No, there are currently no plans to allow this. It seems a bit odd to allow an initializer to bypass a base class constructor (if any); it would seem to make more sense to allow a base-class specifier to contain an initializer:
class derived_1 : public base = {1}
{
};
You might consider submitting a proposal, if you can explain how the language would benefit (do you have a concrete use case?).
As a workaround, you might consider using a class template:
template<int I = 0>
class base { protected: int member = I; };
class derived_1: public base<1> {};
If you need to preserve a common base class, use an intermediate base class template:
class base { protected: int member = 0; };
template<int I>
class base_init: public base { base_init() { base::member = I; } };
class derived_1: public base_init<1> {};
Not sure if it's relevant, but the rules on aggregates and aggregate initialization look likely to change in C++14: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2013/n3653.html
No and Never.
All fields of base class must be initialized in the constructor in base class. Only the constructor in base class know how its field should be initialized.
You can and must initialize an object or its fields through its constructor.