Can you use more than one constructor in a class in c plus plus?

Answer 1

Yes, you can use, and often you should, use more than one constructor in a class in C++.

Normally, there is a default constructor, a copy constructor, and one or more conversion constructors. Sometimes, there are also other constructors, overloaded based on argument signature, if there are complex situations.

Answer 2

C++ has three basic constructors: a default constructor (one with no arguments or where all arguments have default values), a copy constructor and a move constructor. You can also define your own constructors, so long as each has a unique signature.

If you do not define any constructors, the three basic constructors are generated for you by the compiler. If you define any constructor, you lose the compiler-generated default constructor unless you define your own.

The compiler-generated constructors perform member-wise initialisation. In most cases this is fine, particularly if you use Resource Acquisition Is Initialisation (RAII) techniques (e.g., smart pointers). However, if you need to establish class invariants, you must define your own constructor(s) to cater for them. Copy and move constructors will still be generated by the compiler and if using RAII will be sufficient. The only real reason to declare your own copy or move constructors is in cases where you wish to physically disable them.

The compiler also generates copy and move operators as well as a destructor. Most class designers like to be explicit with their construction, assignment and destruction however the latest standard (C++11) permits designers to simplify their declarations to explicitly use compiler-generated defaults:

class A

{

public:

~A () = default;

A () = default;

A (const A&) = default; // copy

A& operator= (const A&) = default;

A (A&&) = default; // move

A& operator= (A&&) = default;

// user-defined members...

};

To delete any compiler-generated method, use =delete in place of =default. This will result in a compile-time error if those methods are called and is much better than previous techniques that involved using private methods without function bodies.

Answer 3

There are three basic constructors: the default constructor (one that accepts no arguments or where all the arguments have default values); the copy constructor and the move constructor. But you can also have any number of overloaded constructors over and above these three. There are no limits to the number of constructors you can define, other than those imposed by the architecture (e.g., memory restrictions).

Answer 4

All constructors have two things in common: they all create a new instance of an object, and they do not specify a return type (a reference to the class is implied, or a pointer to the class if it is created with the new keyword).

The purpose of the constructor is to allow the class developer to initialise the class member variables to default values, or to values specified by the caller. Constructors may also invoke internal methods or external functions to further initialise the class.

Constructors may be public, protected, or private, as required by the class. Typically, there will be at least one public or protected constructor. If all constructors are declared private, no instance of the class can be created (useful for classes that have no member variables and all member methods are declared static).

The default constructor is implied (with public access) when not explicitly declared. A default constructor takes no arguments, however you may include arguments in your override provided all the arguments are given default values. If your class includes member variables you will typically override the default constructor to ensure those variables are initialised correctly. Derived classes will automatically invoke their base class default constructor(s) which should be declared protected or public. Private default constructors are also permitted provided the derived classes are also declared friends of the base class (this feature should only be considered when you do not expect to derive additional classes from the base class).

The copy constructor accepts one argument; a constant reference to another instance of the same class. The default implementation will perform a member-wise copy of the argument (a shallow-copy). Sometimes this is sufficient and there is no need to override the copy constructor. However, if your class contains a pointer to allocated memory, the copy will end up pointing at that same memory location. Sometimes this may be desirable (if the memory were allocated outside of the class, for instance) but if the memory is allocated within the class then the assumption is it will also be released by the instance that allocated it. That is a recipe for disaster when two instances point at the same memory; which instance actually owns the memory, and what happens when either instance is destroyed? The safest solution is to perform a deep-copy of the memory so both instances point to different memory locations, in which case the copy constructor must be overridden. If you do not wish copies of your class to be made, declare the copy constructor private.

Additional construction overloads can be provided by the developer to increase the flexibility with which a user can create instances of the class. For example, if your class has a double member variable, you might allow users to initialise the class member by passing a double into a constructor overload. You might also consider allowing the class to be initialised by passing an integer, or some other numeric type, so the class can handle the type-casting internally, rather than expecting the user to do it. Other uses for constructor overloading include the ability to instantiate your class from an instance of another class entirely, essentially allowing you to "morph" one class type into an entirely different class type, which may include base classes and derived classes. This is a powerful feature, but should only be used where it makes sense to do so. If the end result is an invalid object, then it makes no sense to allow the object to be constructed in the first place.

If your class has multiple members, it can often be useful to create a structure from those members, and to provide a constructor to accept the structure as an argument, thus giving users of your class additional flexibility in creating instances of your class.

The assignment operator is not a constructor (it assigns values to an existing instance of a class, it does not create a new instance), however it is considered good practice to include an assignment operator overload for every constructor overload except the default constructor and those that accept multiple arguments (you can only assign one value with assignment, but structures and classes can be used wherever it is deemed appropriate). This will greatly increase the flexibility of your class. As a general rule, the more flexible your class is, the more your users, and particularly yourself, are likely to use it, which is surely the whole point of creating the class in the first place.

Answer 5

Default, Copy, Conversion, Implied (a case of default).