destroying dynamically allocated memory (array object) in C++

Question

below you will find a code (that compiles/runs), which in brief invokes a function which allocates an array dynamically on the heap.

#include "stdafx.h"

#include <stdio.h>

class A
{

    public:

    A()
    {
        printf ( "constructor has been called !!! \n" );
    }

    ~A()
    {
        printf ( "destructor has been called !!! \n" );
    }

    char* f( void )
    {

        //char *data_raw = NULL;

        data_raw = NULL;

        data_raw = new char [ 20 ];

        for( int i = 0; i < 20; i++ )
        {
            data_raw[ i ] = '0';    
        }

        data_raw[  0 ] = 'h';
        data_raw[  1 ] = 'e';
        data_raw[  2 ] = 'l';
        data_raw[  3 ] = 'l';
        data_raw[  4 ] = 'o';
        data_raw[  5 ] = ' ';
        data_raw[  6 ] = 'w';
        data_raw[  7 ] = 'o';
        data_raw[  8 ] = 'r';
        data_raw[  9 ] = 'l';
        data_raw[ 10 ] = 'd';
        data_raw[ 11 ] = '!';

        return data_raw;

    } //data raw ptr-var is destroyed

    private:

        char *data_raw;

};


int  _tmain( int argc, _TCHAR* argv[] )
{

    char *data = NULL;

    printf( "data: %c", data );

    A a;

    data = a.f();

    delete [] data;  

    return 0;

}

My questions:

1) regarding destroying the memory allocated dynamically, should I use delete or delete [ ] ? both of them compile...

2) when I use the former ( delete ), the class destructor gets invoked, but not when I use delete [] ?

Answer 1

You should simply never ever use a class such as A, particularly not the way you use it.

Specifically:

• You should not transfer ownership of memory while keeping a pointer to the owned object (unless it's a weak reference). This almost always means you're making the invalid assumption that the pointer is valid, despite the fact that the memory could easily have been deallocated long before the non-owning pointer is used.
• You should not directly allocate and deallocate memory except in very special cases. Use existing container classes, or if none are appropriate, use smart pointers - std::unique_ptr, std::shared_ptr and std::weak_ptr - as appropriate.
• You shouldn't pass pointers to allocated memory where the allocated amount (or a lower bound on the allocated amount) is not well-known to the new owner. Either pass references to proper objects, or pass containers using move semantics, or pass spans around. Note that this might happen when you simply just pass values around (due to copy ellisions).
• You should usually prefer keeping ownership of memory with the creator object, allowing for non-owning access and letting the creator object destroy what it created.

Your code follows none of these guidelines! It's scary and dangerous!

I would rewrite your code so as to follow your guidelines, but since it's not clear why you even need method f or class A, I would end up with just:

#include <iostream>
#include <string>

std::string A_f() { return "hello world"; }

int main( int argc, const char* argv[] )
{
    std::cout << A_f();
}

or just

#include <iostream>

int main( int argc, const char* argv[] )
{
    std::cout << "hello world";
}

Answer 2

you call delete[] when you initialize an array in the heap with new and you use delete when initializing an object in the heap with new.

on a side note, i would suggest that you delete the members of a class by its owner. you will be asking for a lot of trouble if you do what you doing here. deleting the array outside of the A.

for this example, there is nothing stopping you to call delete[] data_raw in the destructor of the class A. no need to acceses it from the outside of A or even return a pointer to the array.

class A
{
public:
   A()
  {
    printf ( "constructor has been called !!! \n" );
    data_raw = NULL;
    data_raw = new char [ 20 ];
    //....rest ofthe code from f( void )
    //....no need to return data_raw        
  }

  ~A()
  {
    printf ( "destructor has been called !!! \n" );
    delete [] data_raw; 
  }

private:
  char *data_raw;
};