1.
Variables globales ordinaires - la portée est l'intégralité du programme source (contenant plusieurs fichiers source, valides dans chaque fichier source)
Variables globales statiques - la portée est dans le fichier source actuel
2.
Référence
(1) Lors de la déclaration d'une référence, celle-ci doit être initialisée
(2) La variable de référence est un alias de la variable cible, qui est équivalent à la variable cible, mais avec un nom différent
(3) Déclarer une référence ne signifie pas définir une nouvelle variable, mais seulement une référence à la variable cible. Un alias. La référence elle-même n'est pas un type de données, elle n'occupe donc pas d'unité de stockage, et le système n'attribuera pas d'unité de stockage à la
référence. (4 ) Trouver l'adresse de la référence revient à trouver l'adresse de la variable cible, &a == &i
(5) Lorsqu'on est dans la fonction appelante, les deux valeurs de la fonction appelante sont échangées. La méthode courante est pour transmettre l'adresse de la variable. La deuxième méthode consiste à transmettre la référence
int i =3;
int & a = i; //Ici a est la variable i, printf(i) == printf (a), printf(&a) = = printf(&je)
//被调函数：
void f(int &a, int &b)
{
int t = a;
a = b;
b = t;
}
//主调函数：
main
{
int a = 1, b = 2;
f(a, b); //实参已经交换
}
Mais si la variable locale est définie comme variable locale statique :
int &f()
{
static int i = 10; //静态局部变量，在全局区，静态变量等到整个程序运行结束后才会释放
return i;
}
main()
{
int &p = f(); //返回的静态变量要等到整个程序运行结束才释放
cout << p << endl; //10，
cout << p << endl; //10
}
(6) Une fois qu'une référence est initialisée, elle ne peut plus être modifiée.
int i = 10;
int &b = i; //现在b就是变量i的别名
int j = 100;
b = j; //并没有把b转变为变量j的别名，这里相当于把100赋值给b，又因为b是变量i的别名，也就相当于把100赋值给i
(7) Références en tant que valeurs de retour de fonction
Ne renvoyez pas de références à des variables locales :
int & f()
{
int i = 10;
return i; //返回局部变量引用
}
main()
{
int &p = f(); //返回局部变量引用
cout << p << endl; //10，函数运行结束局部变量销毁，这里编译器第一次保留了返回值
cout << p << endl; //1013313，第二次打印乱码，编译器不再保留数值
}
Mais si la variable locale est définie comme variable locale statique :
int &f()
{
static int i = 10; //静态局部变量，在全局区，静态变量等到整个程序运行结束后才会释放
return i;
}
main()
{
int &p = f(); //返回的静态变量要等到整个程序运行结束才释放
cout << p << endl; //10，
cout << p << endl; //10
}
(8) Si la valeur de retour de la fonction est une référence, cette fonction peut être utilisée comme lvalue
int &f()
{
static int i = 10;
return i;
}
main()
{
int &p = f(); //函数返回引用给p，此时引用p是变量i的一个别名
cout << p << endl; //10
f() = 100; //函数返回变量i值，这时变量i又被赋值100，又因为上面p是变量i的别名，等于p被赋值100
cout << p << endl; //100
}
(9) L'essence d'une référence est une constante de pointeur, l'adresse est immuable et la valeur est variable.
int a = 10;
int &b = a; //实际是int * const b = &a;
b = 20; //实际是*b = 20;
(10) Référence constante
int i = 10;
int &p = i; //给引用赋的是变量，如果int &p = 10; 直接赋常量报错
const int &p = 10; //常量引用可以直接赋值，编译器做了一个默认操作，int tmp = 10;然后const int &p = tmp; 而且常量引用值是不可以修改的，因为常量引用本质是常量指针常量，const int * const p = &tmp;
3.
La casse dans l'instruction switch est suivie d'une constante ou d'une expression constante, et il s'agit d'un entier, d'une énumération ou d'un caractère.
4.
int * f(); //La fonction Pointer renvoie un pointeur de type Int
int (*f)(); //Le pointeur de fonction renvoie une valeur de type int, mais cette fonction est un pointeur vers un pointeur de fonction, s'il y a est une autre fonction g() assignée à f, elle peut être f = g, ou f=&g. Parce que le nom de la fonction est aussi l'adresse de la fonction.
5.
char * p[3] //Tableau de pointeurs, chaque élément est une chaîne de type char *
char (*p)[3] //Pointeur de tableau, équivalent à char p[][3] tableau bidimensionnel
