The new and delete operators in C++ are used for dynamic memory allocation and deallocation. New allocates memory at runtime and returns a pointer to the allocated block. Delete frees up memory that was previously allocated by new. The general syntax for new is pointer = new datatype and for delete is delete pointer. Dynamic memory allocation allows programs to be more flexible by allocating memory as needed at runtime rather than statically.

2.  Reserves memory from a much larger free
store, or heap
 Gives the programmer a pointer to refer to
this memory

3. There are two types of memory management
operators in C++:
 new
 delete
These two memory management operators
are used for allocating and freeing memory
blocks in efficient and convenient ways.

4. The new operator in C++ is used for dynamic
storage allocation. This operator can be used
to create object of any type.

5. The general syntax of new operator in C++ is
as follows:
pointer variable = new datatype;
In the above statement, new is a keyword
and the pointer variable is a variable of type
datatype.

6. For example:
int *a=new int;
The new operator allocates sufficient
memory to hold the object of datatype int
and returns a pointer to its starting point.
The pointer variable a holds the address of
memory space allocated.

7. Dynamic variables are never initialized by
the compiler. Therefore, the programmer
should make it a practice to first assign
them a value.

8. The assignment can be made in either of
the two ways:
int *a = new int;
*a = 20;
or
int *a = new int(20);

9. Dynamic memory allocation in case of
arrays can be done as following:
int* a = new int[x];
a points to a block of memory
containing x ints

10. The delete operator in C++ is used for
releasing memory space when the object
is no longer needed. Once a new operator
is used, it is efficient to use the
corresponding delete operator for release
of memory.

11. The general syntax of delete operator in
C++ is as follows:
delete pointer_variable;
In the above example, delete is a keyword
and the pointer_variable is the pointer
that points to the objects already created
in the new operator.

12.  The programmer must take care not to
free or delete a pointer variable that has
already been deleted.
 Overloading of new and delete operator is
possible (to be discussed in detail in later
section on overloading).

13.  We know that sizeof operator is used for
computing the size of the object. Using
memory management operator, the size
of the object is automatically computed.
 The programmer must take care not to
free or delete pointer variables that have
not been allocated using a new operator.

14.  Null pointer is returned by the new
operator when there is insufficient
memory available for allocation.

15. #include <iostream.h>
void main()
{//Allocates using new operator memory
space //in memory for storing a integer
datatype
int *a= new a;
*a=100;
cout << " The Output is:a="<<a;
//Memory Released using delete operator
delete a;

16. The Output is:a=100

17. The constructors can also be used to allocate
memory while creating objects. This will
enable the system to allocate the right
amount of memory for each object when the
objects are not of the same size, thus
resulting in the saving of memory. Allocation
of memory to objects at the time of their
construction is known as dynamic
construction of objects. The memory is
allocated with the help of
new operator

18. # include <iostream.h>
# include <conio.h>
# include <string.h>
class str
{
char *name;
int len;
public:
str()
{
len=0;
name=new char[len+1];
}
str(char *s)
{
len=strlen(s);
name=newchar[len+1];
strcpy(name,s);
}
void show()
{ cout<<"NAME IS:->"<<name<<endl;
}
void join(str &a,str &b);
};

19. void str::join(str &a,str &b)
{
len=a.len+b.len;
delete name;
name=newchar[len+1];
strcpy(name,a.name);
strcat(name,b.name);
};

20. void main()
{
clrscr();
char *first="HARSHIL";
str n1(first), n2("NINAD"), n3("PRATIK"), n4, n5;
n4.join(n1,n2);
n5.join(n4,n3);
n1.show();
n2.show();
n3.show();
n4.show();
n5.show();
}