What is the advantage and disadvantage of constructor in c plus plus?

Answer 1

Objects allow you to establish invariants and limit the type of operations that can be performed upon the internal representation of the object, exposing only as much as is needed to use the object -- no more and no less. This greatly reduces the chances of the programmer making an error, creating more robust code more easily and with fewer runtime checks and much greater efficiency.

Answer 2

Template Functions

There aren't any demerits to a template function compared to the many demerits of a macro function. The only real pitfall is that types are not automatically promoted as they are with a macro function, however that is actually a good thing because macros cannot enlist the help of the compiler to assure type safety. Take the following example:

#define MAX(a,b) (a)>(b)?(a):(b)

While the above macro can automatically cater for any mixture of types, (int, int), (int, char), (float, double), etc, the problem is that with mixed types there's no guarantee the return type will be suitable for the caller. Even if the compiler picks up a problem, it cannot help you identify the problem because the macro no longer exists by the time the compiler spots the error, and it can't highlight the error because it's looking at the precompiled code rather than the code you actually wrote. Remember that the compiler exists to not only build your programs, but to identify silly little bugs like this. With macro functions you lose this most basic functionality, thus the onus shifts to the programmer to ensure such bugs do not arise.

With function templates you automatically enlist the help of the compiler thus ensuring your function calls are 100% type safe. And if you should mix your types inappropriately, at least the compiler can identify the problem allowing you to cast your types more appropriately.

Template Classes

The only real demerit to a template class is that the class implementation (both the declaration and its definition) must be completely visible to the compiler before the the template is first used. All this really means is that all the code must be placed within the header file rather than separated between header and source files as would be expected of a non-template class. There are ways around this (such as including the source file in the header), however it's hardly a major problem when it's an expected feature of the language.

Answer 3

Binary files allow you to read and write any type of data, including text data, both in ASCII and UNICODE formats. Although all data can be converted to and from an ASCII character array, and could therefore be read and written from a plain-text file, the conversion process alone would make reading and writing mixed data a highly inefficient process. With binary files, no conversion is necessary -- you simply read the data directly into a data buffer of the required type (the type alone determines how many bytes to read or write). This makes it possible to serialise objects simply by reading and writing data members to and from a binary file.

Answer 4

The only merit to an inline function is that you retain the function in your source code (making your code easier to read and manage), whilst the compiler eliminates the expense of an actual function call by inline expanding your function at each call site. The demerit of inline expansion is that it can increase code size to the point that any benefits gained by removing the function calls are outweighed by the reduced performance of the larger code size. As a result, the compiler is free to veto any inline expansion when there is no benefit to be gained in doing so. Declaring a function for inline expansion is merely a hint to the compiler, nothing more.

Answer 5

The merit of a friend function is that it allows an external non-member function to gain private access to the class in which it is declared a friend, thus extending the interface of the class. The demerit of a friend is when it is used inappropriately, which has the potential to undermine encapsulation.

Answer 6

Constructors exist purely to initialise member variables. Although you can use the constructor body to call member methods in order to perform that initialisation, this is highly inefficient, particularly when the member variable is a complex type (non-primitive). Constructors have initialisation lists specifically for the purpose of initialising member variables at the point of instantiation, which is far more efficient than initialising via the constructor body, which would result in complex types being initialised twice (once during implicit initialisation and then again during explicit initialisation in the constructor body).

However, if you specify two or more constructors, each has to have its own specific initialisation list, even if those lists are largely the same for all constructors, which not only results in code duplication but also increases code maintenance. When you add a new member, you must update the initialisation lists of all constructors. Thus the advantage of constructors is increased efficiency, while the disadvantage is increased maintenance. A lot of young programmers often counter this by creating a common initialisation member function which is then called from each constructor's body. While this reduces code maintenance, it increases the inefficiency. There's nothing wrong with having a common initialisation function, but you shouldn't call it from the constructor.

Initialisation lists also allow derived classes to invoke specific base class constructors. When not specified, a derived class constructor will automatically call the base class' default constructor, which may not be the most efficient method of construction. This is particularly important when defining a copy constructor. In this case you will want to call the base class copy constructor, not the base class default constructor, in order to maintain efficiency.

It should be noted that when you do not declare any constructors, the compiler will generate both a default constructor and a copy constructor, both of which will call the appropriate base class constructors if the class is derived. If you define any constructor, you will automatically lose the compiler-generated default constructor and must define your own if you require one. The copy constructor is always generated for you unless you explicitly declare your own, but you must then call the base class copy constructor explicitly, otherwise the base class default constructor is called implicitly.

Answer 7

* case sensitive

* not suitable for large amount of codings

*

Answer 8

advantages and disadvantages of constructer

Answer 9

Compared with what? There are no merits or demerits. Construction is the only way to initialise an instance of a class.