Есть следующий код

typedef char* PChar;

void FillString(PChar *data, int DataSize){

    for (int i = 0; i < DataSize; i++)
    {
        ...
        *data = new char[z];
        ...
        data++;
    }
};

...
PChar *arr = new PChar[DataSize]
FillString(arr, DataSize);
...

как правильно осободить память для каждого элемента массива arr?

Здравствуйте, sps608, Вы писали:

S>Есть следующий код


S>

S>typedef char* PChar;

S>void FillString(PChar *data, int DataSize){

S>    for (int i = 0; i < DataSize; i++)
S>    {
S>        ...
S>        *data = new char[z];
S>        ...
S>        data++;
S>    }
S>};

S>...
S>PChar *arr = new PChar[DataSize]
S>FillString(arr, DataSize);
S>...
S>

S>как правильно осободить память для каждого элемента массива arr?

Правильное решение пользоваться std::vector вместо динамического массива.
Он заботится об освобождении памяти сам.
И тогда такие вопросы отпадут сами

P.S.
На мой взгляд если в коде есть ручной вызов delete это плохой код.

Здравствуйте, sps608, Вы писали:

S>как правильно осободить память для каждого элемента массива arr?
В обратном порядке:

  for (int idx = 0; idx < DataSize; ++idx)
  {
    delete[] arr[idx];
  }
  delete[] arr;

S>>как правильно осободить память для каждого элемента массива arr?

__>Правильное решение пользоваться std::vector вместо динамического массива.
__>Он заботится об освобождении памяти сам.
__>И тогда такие вопросы отпадут сами

Нет, меня не интерсует на данный момент std::vector, как им пользоваться я знаю.
Я пять лет не садился за C++ и мне нужно вспомнить как правильно работать с указателями.

Здравствуйте, Greg Zubankov, Вы писали:

GZ>Здравствуйте, sps608, Вы писали:

S>>как правильно осободить память для каждого элемента массива arr?
GZ>В обратном порядке:

GZ>

GZ>  for (int idx = 0; idx < DataSize; ++idx)
GZ>  {
GZ>    delete[] arr[idx];
GZ>  }
GZ>  delete[] arr;
GZ>

Получаю ошибку: "Heap corruption detected: after Normal block #212 at .... CRT detected that te apllication wrote to memoryafter end of heap buffer"

если сделать так:

    for (int i = 0; i < DataSize; ++i)
    {
        delete[] arr;
        arr++;
    }

то после превого цикла получаю, что arr bad pointer...

Здравствуйте, sps608, Вы писали:

S>если сделать так:


S>

S>    for (int i = 0; i < DataSize; ++i)
S>    {
S>        delete[] arr;
S>        arr++;
S>    }
S>

S>то после превого цикла получаю, что arr bad pointer...
так ты сразу первым delete удаляешь массив указателей, так что arr указывает после этого указывает в никуда

Здравствуйте, sps608, Вы писали:

S>Получаю ошибку: "Heap corruption detected: after Normal block #212 at .... CRT detected that te apllication wrote to memoryafter end of heap buffer"

Код корректный, может у тебя где-то еще ошибка.
Посмотри короткий пример на основе твоего. Здесь нет утечек памяти.

typedef char* PChar;

void FillString(PChar *data, int DataSize){

  for (int i = 0; i < DataSize; i++)
  {
      *data = new char[123];
      data++;
  }
};

int main()
{

  int DataSize = 19;
    PChar *arr = new PChar[DataSize];
  FillString(arr, DataSize);

  for (int idx = 0; idx < DataSize; ++idx)
  {
    delete[] arr[idx];
  }
  delete[] arr;
}

Здравствуйте, sps608, Вы писали:


S>>>как правильно осободить память для каждого элемента массива arr?

__>>Правильное решение пользоваться std::vector вместо динамического массива.
__>>Он заботится об освобождении памяти сам.
__>>И тогда такие вопросы отпадут сами

S>Нет, меня не интерсует на данный момент std::vector, как им пользоваться я знаю.
S>Я пять лет не садился за C++ и мне нужно вспомнить как правильно работать с указателями.


Вот :

char** pp;
const size_t count = 10;
const size_t inner_count = 10;
pp = new char*[count];
for(size_t i = 0; i != count; ++i)
  pp[i] = new char[inner_count];


// работаем

// удаление
for(size_t i = 0; i != count; ++i)
  delete[] pp[i];
delete pp[i];

P.S.
Но в хорошей программе такое писать низачто

Здравствуйте, _nn_, Вы писали:

__>char** pp;
__>const size_t count = 10;
__>const size_t inner_count = 10;
__>pp = new char*[count];
__>for(size_t i = 0; i != count; ++i)
__>  pp[i] = new char[inner_count];


__>// работаем

__>// удаление
__>for(size_t i = 0; i != count; ++i)
__>  delete[] pp[i];
__>delete [] pp   ;
//        ~~   ~~~

Ну и конечно же, этот код совершенно не устойчив перед исключениями bad_alloc.

Здравствуйте, _nn_, Вы писали:

__>P.S.
__>На мой взгляд если в коде есть ручной вызов delete это плохой код.

А как же тогда написать smart_ptr ?

Здравствуйте, VoidEx, Вы писали:

VE>Здравствуйте, _nn_, Вы писали:

__>>P.S.
__>>На мой взгляд если в коде есть ручной вызов delete это плохой код.

VE>А как же тогда написать smart_ptr ?
VE>

Я имел ввиду что следует пользоваться обертками.
Естественно где-то будет ручной вызов delete, но он будет только на самом нижнем уровне, а в коде программы его не будет видно