Есть ли утечка памяти, если да, то почему?
Предположим, у меня есть функция, которая возвращает char *
char* GetName(int index);
И есть еще одна функция, которая имеет char * в качестве входного параметра
void PrintName(const char* name);
так что если я сделаю
PrintName( GetName(10) );
есть утечка памяти?
Если да, то почему?
И это единственный способ справиться с этим без использования std :: string:
char* name = GetName(10);
PrintName(name);
free(name);
Решение
Зависит от того, что делает GetName вернуть.
Но как вы использовали free( name ) Я предполагаю, что он возвращает динамически распределенную память.
Тогда да, есть утечка памяти.
C ++ не имеет сборщика мусора. Если вы выделяете память, вам нужно освободить ее.
Или используйте умный указатель. Или обертка.
Другие решения
Это не утечка памяти, если вы освобождаете () область памяти, возвращаемую GetName (). Но все зависит от того, что происходит внутри GetName ();
Из того, что вы поделились, нет ничего, что называется утечкой памяти, так как вы еще не назначили память, которая может утечь. Вы только что указали, что можете выделить немного памяти и передать ее.
Короче говоря, это полностью зависит от того, что вы пишете внутри функций GetName & PrintName
Это просто, каждый malloc должен быть сопоставлен с freeкаждый new с deleteкаждый new[] с delete[], Вы не говорите, чтоGetName делает, но я предполагаю, что он использовал malloc, В этом случае у вас утечка памяти, так как вы не звоните free,
Второй кусок кода — это один из способов избежать утечки памяти, другой — вызвать free в PrintName (вероятно, не очень хорошая идея, так как вы не сможете позвонить PrintName без динамически выделяемой памяти).
Конечно, именно потому, что это трудно, что вам рекомендуется использовать std::string,
Делая это alloc / dealloc вручную запрашивает проблемы, если вы не осторожны … Так что лучше всего использовать что-то вроде std: string.
Сказав это, если char * расположен внутри GetName, то его нужно удалить снаружи. Вы можете думать об этом как о праве собственности: GetName отдает право собственности, возвращая char *, так что это до того, кто получает char *, чтобы продолжить обрабатывать его. Вы можете либо решить, что PrintName становится владельцем, а затем удалить его, либо сделать так, как вы показали в своем последнем примере.
Одним из более простых подходов является предварительное распределение (предпочтительно в стеке):
char name[TheSizeYouNeed];
PrintName (GetName(10, name));
где GetName будет делать так:
char *GetName (int len, char *buf) {
strcpy (buf, "xxx");
return buf;
}
Трудно сказать из того, что вы написали.
В основном, если вы не используете malloc ключевое слово, то вам не нужно звонить free, память, выделенная в стеке (т.е. без использования malloc) будет выпущен, когда его объем закончится.
Но если вы выделены внутри GetName с помощью mallocНЕ звонит free приведет к утечке памяти.
Итак, все сводится к этому:
- Если вы не использовали
mallocне протечет. - Если вы использовали
mallocи не звонить бесплатно, это протечет.
detector