web-dev-qa-db-ja.com

「参照」および「逆参照」の意味

すべてのウェブサイトが異なることを言っているので、インターネットでさまざまなことを読んで混乱しました。

Cについて話す.

*参照演算子と&参照演算子について読みました。または、その参照とは、変数を指すポインターを作成し、逆参照することは、ポインターが指す変数の値にアクセスすることを意味します。だから私は混乱しました。

「参照と逆参照」について簡単だが完全な説明を得ることができますか？

cpointersreferencedereference
56
Milkncookiez

参照 既存の変数のアドレスを取得して（＆を使用して）ポインター変数を設定することを意味します。有効にするには、ポインターをアスタリスクなしで、ポインターと同じ型の変数のアドレスに設定する必要があります。

int  c1;
int* p1;
c1 = 5;
p1 = &c1;
//p1 references c1

参照解除 ポインタは、*演算子（アスタリスク文字）を使用して、ポインタが指すメモリアドレスから値を取得することを意味します。注：ポインタのアドレスに格納されている値は、変数の型と同じ型の値でなければなりませんポインターは「指す」が、 保障はありません これは、ポインターが正しく設定されていない場合に当てはまります。ポインターが指す変数のタイプは、最も外側のアスタリスクを引いたタイプです。

int n1;
n1 = *p1;

無効な逆参照 クラッシュを引き起こす場合としない場合があります。

  • 初期化されていないポインターを逆参照するとクラッシュする可能性があります
  • 無効な型キャストを使用した逆参照は、クラッシュを引き起こす可能性があります。
  • 動的に割り当てられ、その後割り当て解除された変数へのポインターを逆参照すると、クラッシュが発生する可能性があります
  • スコープ外になった変数へのポインターを逆参照すると、クラッシュする可能性があります。

無効な参照 クラッシュよりもコンパイラエラーを引き起こす可能性が高いですが、これをコンパイラに依存するのは得策ではありません。

参照：

http://www.codingunit.com/cplusplus-tutorial-pointers-reference-and-dereference-operators

& is the reference operator and can be read as “address of”.
* is the dereference operator and can be read as “value pointed by”.

http://www.cplusplus.com/doc/tutorial/pointers/

& is the reference operator    
* is the dereference operator

http://en.wikipedia.org/wiki/Dereference_operator

The dereference operator * is also called the indirection operator.
78
A B

私はそれらが反対の意味で使用されることを常に聞いた：

  • &は参照演算子です。何らかのオブジェクトへの参照（ポインター）を提供します

  • *は間接参照演算子です。参照（ポインター）を取り、参照されたオブジェクトを返します。

16
Chris Dodd

はじめに、それらを後方に持っています：&は参照であり、*は逆参照です。

変数を参照するとは、変数のメモリアドレスにアクセスすることを意味します。

int i = 5;
int * p;
p = &i; //&i returns the memory address of the variable i.

変数の参照解除とは、メモリアドレスに格納されている変数にアクセスすることを意味します。

int i = 5;
int * p;
p = &i;
*p = 7; //*p returns the variable stored at the memory address stored in p, which is i.
//i is now 7
11
ApproachingDarknessFish

以下の説明を見つけます。

int main()
{
    int a = 10;// say address of 'a' is 2000;
    int *p = &a; //it means 'p' is pointing[referencing] to 'a'. i.e p->2000
    int c = *p; //*p means dereferncing. it will give the content of the address pointed by 'p'. in this case 'p' is pointing to 2000[address of 'a' variable], content of 2000 is 10. so *p will give 10. 
}

結論：

  1. & [アドレス演算子]は参照に使用されます。
  2. * [スター演算子]は逆参照に使用されます。
9
nagaradderKantesh

参照

&は参照演算子です。メモリアドレスをポインター変数に参照します。

例：

int *p;
int a=5;
p=&a; // Here Pointer variable p refers to the address of integer variable a.

参照解除

参照変数*は、メモリ変数の代わりに変数の値に直接アクセスするために、ポインター変数によって使用されます。

例：

int *p;
int a=5;
p=&a;
int value=*p; // Value variable will get the value of variable a that pointer variable p pointing to.
3
zaursh

*が含まれるコンテキストは、意味を時々混乱させます。

  // when declaring a function
int function(int*); // This function is being declared as a function that takes in an 'address' that holds a number (so int*), it's asking for a 'reference', interchangeably called 'address'. When I 'call'(use) this function later, I better give it a variable-address! So instead of var, or q, or w, or p, I give it the address of var so &var, or &q, or &w, or &p.   

//even though the symbol ' * ' is typically used to mean 'dereferenced variable'(meaning: to use the value at the address of a variable)--despite it's common use, in this case, the symbol means a 'reference', again, in THIS context. (context here being the declaration of a 'prototype'.) 


    //when calling a function
int main(){ 
    function(&var);  // we are giving the function a 'reference', we are giving it an 'address'
  }

したがって、declaringのコンテキストでは、intやcharなどのtype 、dereferencer '*'を使用して、実際に参照（アドレス）を意味する、コンパイラからアドレスメッセージを要求している「expecting char *」というエラーメッセージが表示された場合、混乱を招きます。

その場合、*がtype（int、charなど）の後にある場合、コンパイラは変数のアドレスを予期しています。これは、変数の前にaddress-of演算子 '＆'と呼ばれる参照演算子alosを使用してこれを指定します。さらに、上記で作成した場合、コンパイラーはアドレスが数値ではなく文字値を保持することを期待しています。 （タイプchar * ==文字を持つ値のアドレス）

int* p;
int *a;   // both are 'pointer' declarations. We are telling the compiler that we will soon give these variables an address (with &).

int c = 10;  //declare and initialize a random variable
//assign the variable to a pointer, we do this so that we can modify the value of c from a different function regardless of the scope of that function (elaboration in a second)

p = c; //ERROR, we assigned a 'value' to this 'pointer'. We need to assign an 'address', a 'reference'.
p = &c; // instead of a value such as: 'q',5,'t', or 2.1 we gave the pointer an 'address', which we could actually print with printf(), and would be something like
//so
p = 0xab33d111; //the address of c, (not specifically this value for the address, it'll look like this though, with the 0x in the beggining, the computer treats these different from regular numbers)
*p = 10; // the value of c

a = &c; // I can still give c another pointer, even though it already has the pointer variable "p"

*a = 10;
 a = 0xab33d111;

各変数は、位置（または配列に慣れている場合はインデックス値）と値を持っていると考えてください。各変数に2つの値があり、1つの値はその位置であり、コンピューターに電気で物理的に保存されていること、およびプログラマーが保存したい量や文字を表す値を持っていると考えるには慣れが必要かもしれません。

//Why it's used
int function(b){
    b = b + 1; // we just want to add one to any variable that this function operates on.
} 

int main(){

    int c = 1;  // I want this variable to be 3.

    function(c); 
    function(c);// I call the function I made above twice, because I want c to be 3.

     // this will return c as 1. Even though I called it twice.
     // when you call a function it makes a copy of the variable.
     // so the function that I call "function", made a copy of c, and that function is only changing the "copy" of c, so it doesn't affect the original
}
  //let's redo this whole thing, and use pointers

int function(int* b){ // this time, the function is 'asking' (won't run without) for a variable that 'points' to a number-value (int). So it wants an integer pointer--an address that holds a number.
*b = *b + 1; //grab the value of the address, and add one to the value stored at that address
}

int main(){
    int c = 1; //again, I want this to be three at the end of the program
    int *p = &c; // on the left, I'm declaring a pointer, I'm telling the compiler that I'm about to have this letter point to an certain spot in my computer. Immediately after I used the assignment operator (the ' = ') to assign the address of c to this variable (pointer in this case) p. I do this using the address-of operator (referencer)' & '.
    function(p); // not *p, because that will dereference. which would give an integer, not an integer pointer ( function wants a reference to an int called int*, we aren't going to use *p because that will give the function an int instead of an address that stores an int.

    function(&c); // this is giving the same thing as above, p = the address of c, so we can pass the 'pointer' or we can pass the 'address' that the pointer(variable) is 'pointing','referencing' to. Which is &c. 0xaabbcc1122...


      //now, the function is making a copy of c's address, but it doesn't matter if it's a copy or not, because it's going to point the computer to the exact same spot (hence, The Address), and it will be changed for main's version of c as well.

}

各ブロック内で、（ "（）"内のパラメーターを介して）に渡される変数（存在する場合）をコピーします。これらのブロック内で、変数の変更はその変数のcopyに対して行われます。変数は同じ文字を使用しますが、元のアドレスとは異なるアドレスにあります。オリジナルのアドレス「参照」を使用することにより、mainの外部またはmainの子の内部のブロックを使用して変数を変更できます。

1
Tyler Curtis Jowers