关于c ++：各种符号（*，&;等）与参数结合的区别是什么？


What are the distinctions between the various symbols (*,&, etc) combined with parameters?

本问题已经有最佳答案，请猛点这里访问。

Possible Duplicate:
c++ * vs & in function declaration

我知道这对你们中的许多人来说可能是一个非常基本的问题，但我真的很难找到一个好的、彻底的解释，尽管我最擅长的是谷歌搜索。我确信答案是肯定的，所以我的搜索条件一定很糟糕。

在C++中，使用各种符号和它们的组合来标记参数(以及这些参数的参数)。它们的确切含义是什么？

例：void func(int *var)和void func(int **var)有什么区别？那int &var呢？

同样的问题代表返回类型和参数。与int* func(int var)相比，int& func(int var)是什么意思？在争论中，y = func(*x)和y = func(&x)有什么不同？

如果你能给我指出正确的方向，我会非常高兴地读到有关这一主题的大量书籍。此外，我非常熟悉一般编程概念：OO、泛型/模板等，而不是C/C++中使用的符号。

编辑：似乎我给人的印象是我不知道什么是指针。我想知道那是怎么回事：)

所以澄清一下：我完全理解指针是如何工作的。我不明白的是"void func(int&var)"的含义，奇怪的是，我找不到答案。在赋值语句的情况下，"&；"运算符将位于右侧，如"int*x=&y"；但在上面的情况下，"&；"运算符实际上位于左侧。换句话说，它是在L值而不是R值上运行的。这显然没有相同的含义。

我希望我现在能讲得更明白些？

相关讨论

要理解这一点，您首先需要了解指针和引用。我将简单地解释一下您询问的类型声明语法，假设您已经知道什么是指针和引用。

在C语言中，据说"声明遵循使用"。这意味着声明变量的语法模仿了使用变量的语法：一般来说，在声明中，基本类型(如int或float)后面跟有类似表达式的内容。例如，在int *y中，基类型是int，表达式类似于*y。此后，该表达式将计算为具有给定基类型的值。

因此，int *y意味着后来的表达式*y是int。这意味着y必须是指向int的指针。对于函数参数和整个函数声明，这一点同样适用：

1
int *foo(int **bar);

在上面的int **bar中，**bar是一个int，意味着*bar是一个int的指针，bar是一个int的指针，它还声明*foo(arg)是一个int(给定arg的适当类型)，意味着foo(arg)产生一个int.1的指针，因此整个函数Claration读取"foo是一个函数，它获取指向int的指针，并返回指向int的指针。"

C++增加了引用的概念，并在过程中使C样式声明变得有点混乱。由于使用运算符&的地址获取变量的地址必须导致指针，因此c在声明中对&没有任何用途；int &x表示&x是in t，这意味着x是某种类型，其中获取该类型的地址将导致int.2，因此，由于此语法不适用于使用C++，它完全不同的目的。

在C++ EDCOX1中，23表示"EDCOX1×25"是对int的引用。使用该变量不涉及任何操作符"引用"引用，所以引用声明符与操作符地址冲突并不重要。同一个符号在两个上下文中意味着完全不同的事物，并且在允许另一个上下文的上下文中不需要使用一个含义。

因此，char &foo(int &a)声明了一个函数，它引用一个int，并返回一个对char的引用。func(&x)是取x的地址传给func的表达式。

＞1。实际上，在声明函数"declarations follow use"的原始C语法中，更严格地遵循了这一点。例如，您将一个函数声明为int foo(a,b)，而参数的类型则在其他地方声明，这样声明看起来就完全像一个use，而不需要额外的类型名。

＞2。当然，int *&x;可以理解，因为*&x可以是in t，但c实际上并不这样做。

相关讨论

你要问的是指针(*)和引用(&)，我认为这里最好解释一下。

相关讨论

Ex: What is the difference between 'void func(int *var)' and 'void
func(int **var)'? What about 'int &var'?

The same question stands for return types, as well as arguments. What
does 'int& func(int var)' mean, as compared to 'int* func(int var)'?
And in arguments, how does 'y = func(*x)' differ from 'y = func(&x)'?

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
(1)
    <return type> <function name> <parameters>
    void           func            (int *var)

    <parameter> here int *var is a pointer to integer, ie it can point to
    an array or any buffer that should be handled with integer pointer
    arithmetic. In simple terms , var holds the address of the respective
    **actual parameter.**

    eg: int arr[10];
        func(arr);

        int a = 33;
        func(&a);

        Here, &a means we are explicitly passing address of the the variable 'a'.
 (2)
     int m = 0;
     int &var = m;

     Here var means reference, ie it another alias name for variable 'm' ,
     so any change 'var' makes will change the contents of variable 'm'.

     var = 2; /* will change the actual contents of 'm' */

     This simple example will not make sense , unless you understand the context.
     Reference are usually use to pass parameter to function, so that changes made by
     the function to the passed variable is visible at the caller.

     int swap(int &m, int &n) {
         tmp = m;
         m = n;
         n = tmp;
     }  

     void main( void ) {

        int x = 1, y = 2;
        swap(x, y);
        /* x = 2, y =1 */  

     }

(3)
     'int& func(int var)' mean, as compared to 'int* func(int var)'?

      int& func(int var) means the function returns a reference;
      int* func(int var) means the function returns a pointer / address;

      Both of the them has its context;


      int& setNext() {

            return next;  
      }

      setNext() = previous;


      where as

      int* setNext() {

           return &next;
      }

      int *inptr;
      inptr = setNext();
      *inptr = previous;

      In the previous two lines,

      int *inptr <- integer pointer declaration;
      *inptr <- means we are accessing contents of the address pointed by inptr;
      ie we are actually referring to 'next' variable.

      The actual use is context specific. It can't be generalized.  

(4)
    how does 'y = func(*x)' differ from 'y = func(&x)'?                          

     y = func(&x) is already explained.

     y = func(*x) , well i'm not sure if you actually meant *x.


     int swap(int *m, int *n) {
         tmp = *m;
         *m = *n;
         *n = tmp;
     }
相关讨论

符号eDCOX1，0，EDCOX1，1，在C++中有三个含义：

  • 当应用于表达式时，它们分别表示"取消引用"和"地址"。

  • 当类型的一部分时，它们分别表示"指针"和"引用"。

    由于C++不关心任意的间距，所以声明EDCOX1 OR 2是完全相同的声明EDCOX1，3)，在这里你可以更清楚地看到，这是一个对象，称为EDCOX1，4的类型EDCOX1，5，1。

  • 当在两个表达式之间使用时，它们分别表示"乘法"和"位与"。

    • 尽管令人沮丧的是，这并不是内部语法的阅读方式，这要归功于C的类型系统的糟糕遗留。因此，除非您想要一个惊喜，否则请避免涉及指针的单行多声明。

    相关讨论

    符号&；和*分别用于表示引用和指针类型。

    int仅表示类型"int"，int*表示"指向int的指针"，int&表示"对int的引用"，

    指针是用于存储变量地址的变量。引用具有其基类型的语法，但具有指向该类型的指针的语义。这意味着您不需要取消引用它来更改值。

    举个例子，下面的代码块2在语义上是等价的：

    1
    2
    int* a = &value;
    *a = 0;

    还有：

    1
    2
    int& a = value;
    a = 0;

    使用指针或引用作为参数类型的主要原因是为了避免复制对象并能够更改传递的参数的值。这两种方法都有效，因为当您通过引用传递时，只复制地址，这样您就可以访问与"传递"给函数相同的内存位置。

    相反，如果不使用引用或指针类型，则将生成参数的完整副本，而在函数内部可以使用该副本。

    相关讨论