Указатель возвращает и область действия

Question

Возвращает указатель, объявленный внутри функции, считающейся плохой практикой? Пример:

int* foo(void) 
{ 
    int * ret_val = 1234; 

    return ret_val; 
} 

Я считаю, что вы предполагается использовать:

static int * ret_val = 1234; 

Но опять же, не все еще считается плохой практикой вернуть память за пределами вашей сферы?

Answer 1

Возврат указателя не является проблемой, если он указывает на память, которая все еще находится в области видимости, например динамически распределенная память, глобальные данные или локальные переменные, которые все еще существуют в стеке вызовов.

Проблема с вышеуказанным кодом заключается в том, что вы разыскиваете указатель, не присваивая ему ничего. Это: *ret_val = 1234; присваивает значение 1234 по адресу ret_val указывает на, но ret_val ничего не назначен.

Если с другой стороны, вы сделали это:

int* foo(void) 
{ 
    int * ret_val; 

    ret_val = malloc(sizeof(int)); 
    *ret_val = 1234; 

    return ret_val; 
} 

Это нормально, так как вы возвращающая указатель на динамически выделенную память.

Answer 2

Первичный преступник

*ret_val = 1234; 

применяется с неинициализированного указателем.

Я считаю, что вы предполагается использовать:

static int* ret_val; 

Нет, чтобы исправить, что вы могли бы использовать

int* foo() { 
    static int_val = 1234; 
    return &int_val; 
} 

Но это спорно, если это то, что вы действительно хотите. Все вызывающие функции этой функции будут иметь один и тот же экземпляр int_val.

Answer 3

Это очень плохая практика, если вы возвращаете указатель на локальную переменную, потому что у вас будет висячий указатель.

int* foo(void) 
{ 
    int a = 1337; 
    return &a; //Don't do this! 
} 

Но иногда это может быть полезно:

int* copy_array(int *array, int size) 
{ 
    int *v = (int*) malloc (size * sizeof (int)); 
    //..copy the array.. 
    return v; 
} 

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

Answer 4

Помимо использования вами ret_val без него выделяется, возвращая указатель из функции является справедливой практикой, хотя она уделяет особое внимание:

• Не возвращает указатель на локальную переменную, как это будет уничтожен, когда функция выйдет и вызовет неопределенное поведение при разыменовании
• Если функция выделяет память, функция вызывающего абонента отвечает за освобождение указателя, когда он больше не нужен, чтобы избежать утечек памяти.
• Если функция обрабатывает массив в fo п.м. указателя, он должен знать размер массива, чтобы избежать неопределенное поведение, как правило, в качестве дополнительного size параметра или глобальной константы

Answer 5

Вы должны рассмотреть:

int *foo() { 
     int *ret_val = new int(1234); 
     return ret_val; 
} 

вместо (плохой код):

int* foo(void) 
{ 
    int * ret_val; 

    *ret_val = 1234; 

    return ret_val; // dangling pointer! 
} 

иначе вы будете иметь оборванных указатель (второй пример). Очевидно, не забудьте выпустить память. Вы должны также рассмотреть возможность использования смарт-указатели: https://en.wikipedia.org/wiki/Smart_pointer

Как вы определили как C++ и C языки выше код в C++ (оператор новый), пожалуйста, обратитесь к (например) @Mattia F. ответ на ANSI C.

Answer 6

Указатель как ярлык или гиперссылка. Создание только ярлыка не устанавливает программу. Создание гиперссылки не волшебным образом настраивает весь сайт.

То же, что и указатель: a int* - это указатель на целое число. Это не целое число. Таким образом, вы должны убедиться, что указатель указывает на что-то значимое, прежде чем пытаться следовать указателю.

Один из способов сделать так, чтобы создать целое и наборы указатель, чтобы указать на него:

int* ret_val = new int; 

Это создаст целое число (new оператора), а затем устанавливает ret_val указатель на точку к нему.

Объекты, созданные через new, существуют до тех пор, пока вы явно не уничтожите их через delete или когда ваше приложение закончится. По этой причине, если у вас есть функция new int, она безопасна для ее доступа, даже если функция завершается.

Что бы dangereous, и, вероятно, вызвано ваше беспокойство, если вы бы установить указатель ret_val не новое целое, но к существующей локальной переменной, т.е.

int myInteger; 
int* ret_val = &myInteger; 

В таком сценарии, ret_val точки к локальной переменной myInteger, которая уничтожается, когда заканчивается область, содержащая объявление. Вы попадаете в висячий указатель, ссылаясь на то, что не существует (подумайте: сломанная гиперссылка). Использование такого указателя может привести к неопределенному поведению.Это может привести к сбою вашей программы, но она может также молча принять ее, модифицируя случайное пространство в памяти.

---

Таким образом, функция формы:

int* foo(void) 
{ 
    int* ret_val = new int; 
    *ret_val = 1234; 
    return ret_val; 
} 

является безопасным для использования. Это не обязательно хорошая практика: пользователь такой функции должен знать, что она создает новое целое число, которое позже - в какой-то момент - кому-то должно быть delete. Функции, которые делают это, как правило, выделяют такое поведение каким-либо образом, например. через его название. Например, allocateInt() дает понять, что он создал то, что позже должно быть удалено. Напротив, getInt() предполагает, что целое число уже существует и ничего не создано.