aiguille
Définition du pointeur
p est un pointeur, qui représente l' adresse de la valeur stockée ;
* p est la valeur stockée dans l'adresse .
//创建变量a，将值1存储在该变量中
int a = 1;
//创建变量pa，将变量a的地址存储在pa中
int* pa = &a;
//强调*p是一个int类型的值——C程序员
int *p;
//强调int*是一种类型——C++程序员
int* p;
Variable de pointeur vers le paramètre de fonction transfert-échange les valeurs de deux variables
Les paramètres de la fonction peuvent être non seulement des données spécifiques telles que des entiers, des décimales et des caractères, mais également des pointeurs vers eux.
L'utilisation de variables de pointeur comme paramètres de fonction peut transmettre l'adresse en dehors de la fonction à l'intérieur de la fonction , de sorte que les données en dehors de la fonction puissent être manipulées à l'intérieur de la fonction, et ces données ne seront pas détruites à la fin de la fonction.
Les tableaux, les chaînes, la mémoire allouée dynamiquement, etc. sont tous des collections d'une série de données . Il est impossible de les transmettre toutes à la fonction via un seul paramètre . Vous ne pouvez transmettre que leurs pointeurs. Ces ensembles de données sont affectés par les pointeurs à l'intérieur de la fonction.
……
startTest();
……
void MainWindow::startTest()
{
qDebug() << "asd";
int a = 1;
int b = 2;
swap(a, b);
qDebug() << a << b;
}
//Qt中除了构造函数和析构函数，都要加上void或double的类型
void MainWindow::swap(int a, int b)
{
qDebug() << a << b;
int temp = a;
a = b;
b = temp;
qDebug() << a << b;
}
asd
1 2
2 1
1 2
Les valeurs de a et b n'ont pas changé et l'échange a échoué.
Le cycle de vie est différent. Les variables locales définies dans la fonction se terminent après l'exécution de la fonction. Les données peuvent être échangées dans la fonction d'échange, mais les modifications ne peuvent pas être affichées en dehors de la fonction.
Ceci est dû au fait que les a et b à l'intérieur de la fonction swap () et les a et b à l'intérieur de la fonction main () sont des variables différentes, occupant une mémoire différente. Ils n'ont pas d'autre relation que le même nom.
swap () échange les valeurs de a et b à l'intérieur, et n'affecte pas les valeurs de a et b à l'extérieur (main () inside).
……
pStartTest();
……
void MainWindow::pStartTest()
{
qDebug() << "asd";
int a = 1;
int b = 2;
//调用 pSwap() 函数时，将变量 a、b 的地址分别赋值给 p1、p2（都是地址）
pSwap(&a, &b);
qDebug() << a << b;
}
void MainWindow::pSwap(int* p1, int* p2)
{
qDebug() << *p1 << *p2;
int temp = *p1;
*p1 = *p2;
*p2 = temp;
qDebug() << *p1 << *p2;
}
Bien que p1 et p2 soient détruits après l'exécution de la fonction, son impact sur les a et b externes est "persistant" et ne "restaure pas à l'état d'origine" avec la fin de la fonction.
asd
1 2
2 1
2 1
Les variables de pointeur sont utilisées comme paramètres de fonction - les tableaux sont utilisés comme paramètres de fonction
#include <stdio.h>
//C++系列专属
#include <iostream>
using namespace std;
int max(int *intArr, int len)
//int类型的可以不用声明，但是void类型必须声明
int max(int *intArr, int len) {
int i, maxValue = intArr[0]; //假设第0个元素是最大值
for (i = 1; i < len; i++) {
if (maxValue < intArr[i]) {
maxValue = intArr[i];
}
}
return maxValue;
}
int main() {
int nums[6], i;
int len = sizeof(nums) / sizeof(int);//可以得到长度
//读取用户输入的数据并赋值给数组元素
for (i = 0; i < len; i++) {
//scanf_s("%d", nums + i);
//不可以使用nums++，是因为是常量指针
cin >> nums[i];//常量指针
}
//printf("Max value is %d!\n", max(nums, len));
//max函数的返回值是int类型的值，可以直接写
cout << max(nums, len);//nums是数组变量名，也就是数组的首地址
system("pause");
return 0;
}
12 55 30 8 93 27↙(enter)
Max value is 93!
Le paramètre intArr n'est qu'un pointeur de tableau . La longueur du tableau ne peut pas être obtenue à partir de ce pointeur à l'intérieur de la fonction. La longueur du tableau doit être transmise en tant que paramètre de fonction à la fonction (obligatoire) .
Chaque élément du tableau nums est un entier. Lorsque scanf () lit l'entier saisi par l'utilisateur, il requiert l'adresse de la mémoire où il est stocké. Nums + i est l'adresse du i-ème élément du tableau .
Définition des paramètres de tableau
Les trois méthodes suivantes sont toutes possibles, toutes doivent passer la longueur du tableau;
Ni int intArr [6] ni int intArr [] ne créeront de tableau et le compilateur ne leur allouera pas de mémoire. Le tableau réel n'existe pas et ils seront éventuellement convertis en pointeurs int * intArr .
Cette forme de int intArr [6] peut seulement indiquer que la fonction s'attend à ce que le tableau transmis par l'utilisateur ait 6 éléments . Cela ne signifie pas que le tableau ne peut avoir que 6 éléments. Le tableau réel passé peut en avoir moins ou plus de 6 éléments.
Il convient de souligner que quelle que soit la méthode utilisée pour passer le tableau, la longueur du tableau ne peut pas être obtenue à l'intérieur de la fonction , car intArr est juste un pointeur, pas un vrai tableau, donc un paramètre supplémentaire doit être ajouté pour passer le longueur du tableau.
//int max(int intArr[], int len){
//int max(int intArr[6], int len){
int max(int *intArr, int len) {
int i, maxValue = intArr[0]; //假设第0个元素是最大值
for (i = 1; i < len; i++) {
if (maxValue < intArr[i]) {
maxValue = intArr[i];
}
}
return maxValue;
}
Le passage des paramètres de fonction est essentiellement un processus d' affectation , l'affectation consiste à copier la mémoire . La soi-disant copie de mémoire fait référence à la copie de données d'une mémoire vers une autre mémoire.
Pour les types de données de base comme int, float, char, etc., la mémoire qu'ils occupent n'est souvent que de quelques octets, et leur copie mémoire est très rapide.
Un tableau est une collection d'une série de données. Il n'y a pas de limite au nombre de données. Il peut y en avoir quelques ou des milliers. Les copier en mémoire peut être un long processus, ce qui ralentira considérablement l'efficacité du programme. En afin d'éviter les compétences Les programmeurs pauvres écrivent du code inefficace et le langage C ne prend pas en charge syntaxiquement l'affectation directe des ensembles de données.
En plus du langage C, C ++, Java, Python et d'autres langages interdisent également la copie de gros blocs de mémoire et utilisent des méthodes de type pointeur pour l'implémenter au niveau inférieur.