How can template increase the code reusebility in c plus plus?

Answer 1

Templates encourage generic programming. When classes or functions only differ by type, there is no need to write the same implementations over and over -- the compiler generates the functions or classes from the template. You can also cater for specialisation, so if you need a more specific implementation for pointers to types rather than actual types, you can provide the code to cater for this, without the need to duplicate already existing code that caters for all types.

Answer 2

Class reusability is implemented in C++ through inheritance, just as it is with all other object-oriented programming (OOP) languages. Inheritance is the means by which it is possible to derive new classes from existing classes. The new class automatically inherits all the functionality of the existing class, even if the programmer has no access to the source code for the existing class. This is not unlike real-life where it is often quicker to modify an existing component to suit an entirely new purpose.

In C++, inheritance is implemented in the class declaration. For instance, if we have a base class A and wish to derive a new class B from A, then we use the following declaration:

class B : public A {...};

Here, class B automatically inherits all of the public and protected members of A, but none of the private members of A. Only members of A (including friends) have access to the private members of A. Note that friendship cannot be inherited, so if A has any friends they are automatically excluded from the inheritance. In addition, A's constructors, its destructor and its assignment operator are also excluded.

Note that the use of the public keyword does not affect which members are inherited -- that is always determined by the base class member access specifiers. The public keyword simply determines the type of inheritance with respect to the derived class. That is, it determines whether a public or protected member of A is to be treated as being a public, protected or private member of B.

The type of inheritance only affects those members of the base class that have greater access than that specified. Thus public inheritance does not have any effect; the public and protected members of A will remain public and protected members of B. However, protected inheritance would render the public members of A as being protected members of B, while private inheritance would render both the public and protected members of A as being private members of B.

Although the type of inheritance can be used to reduce access to the base class members en-masse, you are still free to override the specified inheritance on a member-by-member basis. Perversely, this also allows you to increase the access of members beyond that of the base class. In other words, a protected member of a base class could become a public member of a derived class. The following example illustrates this:

#include

class A

{

public:

int m_public;

protected:

int m_protected;

private:

int m_private;

};

class B : private A

{

public:

using A::m_protected; // increase access to base class member

};

int main()

{

B b;

b.m_protected=1; // set the "protected" member.

return( 0 );

}

Note that although B uses private inheritance (thus rendering both A::m_public and A::m_protected as private members of B), we have subsequently overridden that access and exposed A::m_protected with public access through B, thus allowing the main function access to a member of A that it would not otherwise have access to. In other words, B has elevated the access of an otherwise protected member.

As an aside, you will often encounter new programmers who will continually cite the urban myth that friends undermine encapsulation. But if that is true, then clearly the same can be said of public inheritance. If anything, public inheritance does far more to undermine encapsulation than friendship ever will. And yet nobody ever says that public inheritance undermines encapsulation. The truth is that neither of them undermine encapsulation; only bad design can do that. If you keep your critical data members private and only permit friend access where it is required, then encapsulation can never be undermined.

Answer 3

Any function that is called more than once from different places is an example of code re-use.

Answer 4

#include <iostream>

using namespace std;

int main ()

{

cout << hello world << endl;

}

this outputs hello world.

Answer 5

Inheritance, Aggregation,Templates.