• Main Menu
  • Constructors that Allocate Memory Dynamically


    Constructors can be used to initialize member objects as well as allocate memory. This can allow an object to use only that amount of memory that is required immediately. This memory allocation at run-time is also known as dynamic memory allocation. The new operator is used for this purpose.

    Sample Program

    The program below shows the use of new in constructors of a simple String class.

     

    /*
     * Program to illustrate use of dynamic memory allocation
     * in constructors
     * http://www.tech-faq.com
     */
    
    #include 
    #include 
    
    class String
    {
        private:
            char *arr;
            int size;
        public:
            String():size(0) // Constructor no. 1
            {
               arr = new char[size+1];
            }
    
            String(char *s):size(strlen(s)) // Constructor no. 2
            {
               arr = new char[size+1]; // one additional byte for '\0' null terminator
               strcpy(arr, s);
            }
    
            void show()
            {
               std::cout << arr << std::endl;
            }
    
            void join(String &a, String &b)
            {
               size = a.size + b.size;
               delete arr;
               arr = new char[size+1];
               strcpy(arr, a.arr);
               strcat(arr, b.arr);
            }
    };
    
    int main(void)
    {
        char *name = "John Carry";
    
        String name1(name);
        String name2("Mark Wills ");
        String name3("Malcolm Marshall");
        String s1, s2;
    
        s1.join(name1, name2); //i.e. s1 = name1 + name2
        s2.join(s1, name3);
    
        name1.show();
        name2.show();
        name3.show();
        s1.show();
        s2.show();
    
        return 0;
    }
    

     

    Output

    John Carry 
    Mark Wills 
    Malcolm Marshall 
    John CarryMark Wills 
    John CarryMark Wills Malcolm Marshall
    

     

    Explanation

    Two constructors are used in the above program. The first is the default (non-parameterized) constructor which initializes size to 0 and dynamically allocates 1 byte of memory to the char* array arr. The second constructor initializes the size to the size of the string entered by the user and then dynamically allocates size +1 bytes of memory for arr. Note that here we have initialized the size of the arr array with 1 byte more than that entered by the user; this is to make place for the null terminator (‘\0’) or end-of-string character.

    In the above program we have used the standard library functions strcpy() and strcat(). strcpy() copies character strings from one memory location to another and strcat() joins two strings into one.

    The class member function join() concatenates two strings and allocates the result to the current object. In main(), the program uses this function to concatenate three strings.

    Got Something To Say:

    Your email address will not be published. Required fields are marked *

    C
    } 238 queries in 0.292 seconds.