各种符号(*，&等)与参数相结合之间有什么区别？

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

在C中，有人说"声明遵循使用"这意味着声明变量的语法模仿使用变量：通常在声明中，会有一个类似int或float的基类型，后面跟着一个看起来像表达式的东西。例如，在int *y中，基本类型是int，表达式look like是*y。此后，该表达式计算为具有给定基类型的值。

所以int *y意味着稍后的表达式*y是int。这意味着y必须是一个指向int的指针。函数参数也是如此，事实上整个函数声明也是如此：

int *foo(int **bar);

在上面的int **bar中，**bar是int，意味着*bar是指向int的指针，bar是指向int指针的指针。它还声明*foo(arg)将是int（给定适当类型的arg），这意味着foo(arg)会导致指向int的指针

C++添加了引用的概念，并在这个过程中稍微混淆了C风格的声明。因为使用运算符&的地址获取变量的地址必然会导致指针，所以C在声明中对&没有任何用处；int &x表示&x是一个int，这意味着x是某种类型，其中获取该类型的地址会产生int。²因此，由于该语法未使用，C++将其用于完全不同的目的。

在C++中，int &x表示x是对int的引用。使用该变量不涉及任何运算符来"取消引用"该引用，因此引用声明符符号与运算符地址冲突并不重要。同一个符号在两种情况下意味着完全不同的东西，在允许使用另一种含义的情况下，从来没有必要使用其中一种含义。

因此，char &foo(int &a)声明了一个函数，该函数引用int并返回char。CCD_ 32是取CCD_ 33的地址并将其传递给CCD_。

_{1.事实上，在声明函数的原始C语法中，"declarations follow use"甚至得到了更严格的遵守。例如，您可以将一个函数声明为int foo(a,b)，并且参数的类型在其他地方声明，这样声明看起来就完全像一个用途，而不需要额外的类型名}

_{2。当然，int *&x;可能是有意义的，因为*&x可能是一个int，但C实际上并没有做到这一点}

您所询问的内容称为指针（*）和对（&）的引用，我认为这里最好对此进行解释。

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

CCD_ 40简单地表示类型"int"，CCD_ 41表示"指向int的指针"，int&表示"对int的引用"，

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

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

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

和：

int& a = value;
a = 0;

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

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

符号*和&在C++中各有三种含义：

1. 当应用于表达式时，它们分别表示"取消引用"answers"地址"，正如您所知。

2. 当它们是类型的一部分时，它们分别表示"指针"answers"引用"。

   由于C++不关心任意间距，声明int *ptr与声明int* ptr完全相同，在声明中您可以更清楚地看到这是一个名为int*类型的ptr的对象¹

3. 当在两个表达式之间使用时，它们分别表示"乘法"answers"逐位and"。

^{1-然而，令人沮丧的是，由于C类型系统的遗留问题，内部语法实际上并不是这样解读的。因此，除非你想要一个惊喜，否则要避免涉及指针的单行多声明}

例如："void func（int*var）"answers"void"之间有什么区别func（int**var）'？"int&var？

同样的问题代表返回类型和参数。什么做'int&func（int var）'平均值，与'int*func（int-var）'相比？在自变量中，"y=func（*x）"与"y=funk（&x）"有何不同？

(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; 
     }