What is a Conversion Constructor

A Conversion constructor is a single-parameter constructor that is declared without the function specifier explicit. The compiler uses converting constructors to convert objects from the type of the first parameter to the type of the converting constructor's class. The following example demonstrates this:

class Y {
 int a, b;
 char* name;
public:
 Y(int i) { };
 Y(const char* n, int j = 0) { };
};

void add(Y) { };

int main() {

 // equivalent to
 // obj1 = Y(2)
 Y obj1 = 2;

 // equivalent to
 // obj2 = Y("somestring",0)
 Y obj2 = "somestring";

 // equivalent to
 // obj1 = Y(10)
 obj1 = 10;

 // equivalent to
 // add(Y(5))
 add(5);
}

The above example has the following two converting constructors:

• Y(int i)which is used to convert integers to objects of class Y.
• Y(const char* n, int j = 0) which is used to convert pointers to strings to objects of class Y
  

A copy constructor is a converting constructor.

What is auto pointer?

The simplest example of a smart pointer is auto_ptr, which is included in the standard C++ library. Auto Pointer only takes care of Memory leak and does nothing about dangling pointers issue. Auto_ptr is a simple wrapper around a regular pointer. It forwards all meaningful operations to this pointer (dereferencing and indirection). Its smartness in the destructor: the destructor takes care of deleting the pointer.

For the user of auto_ptr, this means that instead of writing:

void foo()
{
MyClass* p(new MyClass);
p->DoSomething();
delete p;
}

You can write:

void foo()
{
auto_ptr p(new MyClass);
p->DoSomething();
}
And trust p to cleanup after itself

If you use auto_ptr objects you would not have to be concerned with heap objects not being deleted even if the exception is thrown.

What is Memory Leak?

Memory which has no pointer pointing to it and there is no way to delete or reuse this memory(object), it causes Memory leak.

{
Base *b = new base();
}

Out of this scope b no longer exists, but the memory it was pointing to was not deleted. Pointer b
itself was destroyed when it went out of scope.

What is a dangling pointer?

A Dangling Pointer arises when you use the address of an object after its lifetime is over. This may occur in situations like returning addresses of the automatic variables from a function or using the address of the memory block after it is freed

{
 char *cp = NULL;
 /* ... */
 {
     char c;
     cp = &c;
 } /* c falls out of scope */        
   /* cp is now a dangling pointer */
}

To resolve dangling pointer issue:

#include 
{
  char *cp = malloc ( A_CONST );
  /* ... */
  free ( cp );      /* cp now becomes a dangling pointer */
  cp = NULL;        /* cp is no longer dangling */
  /* ... */
}

Software architecture

The software architecture of a program or computing system is the structure or structures of the system, which comprise software components, the externally visible properties of those components, and the relationships between them. The term also refers to documentation of a system's software architecture. Documenting software architecture facilitates communication between stakeholders, documents early decisions about high-level design, and allows reuse of design components and patterns between projects

Teamwork

Collaboration requires effective team work. Team members must trust and respect one another. There must be open communication and a willingness to accept input from others.

There are often conflicting goals in product development. Therefore decision-making must be based on a collaborative approach. This is shown with the following model.

Collaboration

Collaboration is the basis for bringing together the knowledge, experience and skills of multiple team members to contribute to the development of a new product more effectively than individual team members performing their narrow tasks in support of product development. As such collaboration is the basis for concepts such as concurrent engineering or integrated product development

Effective collaboration requires actions on multiple fronts:

• Early involvement and the availability of resources to effectively collaborate
• A culture that encourages teamwork, cooperation and collaboration
• Effective teamwork and team member cooperation
• Defined team member responsibilities based on collaboration
• A defined product development process based on early sharing of informatin and collaboratin
• Collocation or virtual collocation
• Collaboration technology