Begegnen Zeiger Argument, vorbei Wert in C ++?

Question

Begegnen Zeigerargument, Pass von Wert in C ++? Da ich sehen, dass als solche auf den Zeiger jede Änderung nicht außerhalb des Verfahrens reflektiert wird. Die Änderungen, die ich tun, um den Zeiger zu dereferenzieren wird, obwohl reflektiert.

In diesem Fall ist es akzeptabel / Standardverfahren anzuwenden Zeiger auf Zeiger als Argument eine Funktion, um den Zeigerwert als solcher innerhalb einer Funktion zu ändern?

Answer 1

Ja, um beides.

Zeiger werden von Wert als alles andere übergeben. Das heißt, die Inhalte des Zeigervariable (die Adresse des anvisierten Objekts) wird kopiert. Das bedeutet, dass wenn Sie den Wert des Zeigers in der Funktion Körper ändern, wird diese Änderung nicht in dem externen Zeiger reflektiert werden, die immer noch auf das alte Objekt verweisen. Aber man kann den Wert des Objekts ändern wies auf.

Wenn Sie Änderungen an den Zeiger auf den externen Zeiger reflektieren wollen (es auf etwas hinweisen, sonst), müssen Sie zwei Dereferenzierungsebenen (Zeiger auf Zeiger). Wenn Aufrufe von Funktionen ist es, indem man einen & vor dem Namen des Zeigers getan. Es ist der Standard-C-Weg, Dinge zu tun.

Wenn C ++, Referenzen unter Verwendung von an den Zeiger bevorzugt (im Folgenden auch auf Zeiger auf Zeiger).

Für die Warum Referenzen sollten auf Zeiger bevorzugt werden, gibt es mehrere Gründe:

• Referenzen vorstellen weniger syntaxic Lärm als Zeiger in Funktion Körper
• Referenzen halten mehr Informationen als Zeiger, als nützlich sein kann für Compiler

Nachteile von Referenzen sind meist:

• brechen sie die einfache Pass-by-Wert Regel von C, was das Verhalten einer Funktion macht das Verständnis hinsichtlich der Parameter (werden sie geändert werden?) Weniger offensichtlich. Sie können auch Funktionsprototyp müssen sicher sein. Aber das ist nicht wirklich schlechter als die Mehrfach-Zeigerstufen erforderlich bei der Verwendung von C.
• Sie werden nicht von C unterstützt, die ein Problem sein kann, wenn Sie Code schreiben, der mit beiden C und C ++ Programme funktionieren sollte (aber das ist nicht der Normalfall).

In dem speziellen Fall der Zeiger auf Zeiger, ist der Unterschied meist Einfachheit, aber Referenz verwendet es auch einfach sein kann beide Ebenen von Zeigern entfernen und nur eine Referenz statt einen Zeiger auf Zeiger übergeben.

Answer 2

I understand the confusion here. The concepts of "pass by value" and "pass by reference" are not so clear even if they seem to be so. Bear in mind that the computer does not know these concepts and does not behave according to it. The computer does not know about the types. Hence it does not make a distinction of pointers and values. Let me try to explain by and example:

void func1(int x)
{
   x = 5;
}

void func2(int *x)
{
   int a;
   x = &a;
}

The operation is same for the machine in both functions: It gets the argument and changes it. Note that, in second function it does not modifiy *x, it modifies x.

Now if we call these functions,

int y = 10;

func1(y); //value of y does not change

func2(&y); //value of &y does not change, but the value of the address which y points may change. 

I prefer to say that, basically, every function call is "call by value". But in the case of a pointer type, we have a way to change the content of another address in memory.

If we had written func2 as

void func2(int *x)
{ 
   *x = 5; 
}

Then, this would be a real case of "call by reference".

Answer 3

Either a pointer to a pointer, or a reference to a pointer, is what you would use if you wanted to potentially change the pointer itself. To your original question, technically, yes, all parameters are passed by value.

Answer 4

Yes it is, as it is in C.

In that case, is it acceptable/standard procedure to use pointer to pointer as argument to a function to modify the pointer value as such within a function?

In which case? What do you want? You can use real references with the & modifier.

void func(type &ref);

Answer 5

Pass by value using Pointers I'll explain it by example:

void f(int *ptr)
{
   cout<<*ptr;
}


int main ()
{
   int a=10;
   int *aptr=&a;
   f(aptr);
   return 0;
} 

Here, in main function a is an integer variable whose content is 10 and address is 00F8FB04 (assume). aptr is pointer to integer, that store the address of integer variable a, so aptr content is address of integer variable a that is 00F8FB04. When we pass aptr as the function argument only content of aptr (that is address) are copies to function parameter. So, ptr will receive the copy of content of aptr (that is address 00F8FB04)