Я не понимаю, почему передача указателя на функцию не изменяет передаваемые данные. Если функция proto выглядела так:
void func( int *p );
и func выделяет память на p, почему ее нельзя использовать вне функции? Я думал, что указатели были адресами?
В то время как что-то вроде этого делает то, что вы ожидаете:
void func(int *p)
{
*p = 1;
}
int a = 2;
func(&a);
// a is now 1
это не
void func(int *p)
{
p = new int;
}
int *p = NULL;
func(p);
// p is still NULL
В обоих случаях функция работает с копией исходного указателя. Разница в том, что в первом примере вы пытаетесь манипулировать базовым целым числом, которое работает, потому что у вас есть его адрес. Во втором примере вы манипулируете указателем напрямую, и эти изменения применяются только к копии.
Существуют различные решения для этого; это зависит от того, что вы хотите сделать.
Аргументы в C и С++ передаются по значению. Это означает, что если тип аргумента является указателем на int, тогда функция получает копию фактического аргумента указателя, но все еще может изменить указатель int на.
Очень сложно сказать, что вы просите.
Мое предположение - вы можете изменить память, на которую указывает указатель p, но вы не можете "перенаправить" или удалить указатель (или выделить память)? Если это так, передайте указатель в качестве ссылки: void func( int &*p )
Или как двойной указатель void func( int **p )
чтобы иметь возможность изменить его (я говорю об указателе)
Указатели - это. Если вы передадите указатель на функцию, функция может затем изменить данные, созданные за пределами области действия функции. Однако, если вы хотите выделить память внутри функции для использования вне функции, вам нужно передать двойной указатель. Причина в том, что указатели передаются по значению, а распределение присваивает новое значение указателю для вновь выделенного блока. Но это новое значение теряется при возврате функции. Но вы можете использовать этот метод для выполнения необходимых действий:
void func(int * * pp)
{
* pp = new int;
}
используйте func таким образом:
int * myPointer;
func(& myPointer);
// do stuff with myPointer
delete myPointer;
Я не согласился бы ответить Николаю. В С++ существует два способа передачи аргументов.
f(Type Name)
- ваш случай, где Type int* и Name p (обратите внимание, что int *p на самом деле означает int* p). В этом случае внутри вашей функции Name находится копия объекта, который вы передаете функции.
Второй способ
f(Type & Name)
не создает копию, но вместо этого создает объект псевдоним, поэтому вы можете изменить исходный объект.
В вашем случае объект является указателем типа int*. Когда вы передаете его с использованием первого синтаксиса, вы получаете копию его, которую вы изменяете, и исходный указатель остается неизменным. Если вы хотите изменить исходный указатель, вы должны передать его по ссылке, поэтому для Type = int* и Name= p вы получите
f(int*& p)