Répertoire d'articles
Un, pointeur
La mémoire est accessible indirectement via le pointeur, et le nombre dans la mémoire peut être lu ou écrit
-
Le numéro de mémoire est enregistré à partir de 0, généralement représenté par des nombres hexadécimaux
-
Vous pouvez utiliser des variables de pointeur pour enregistrer des adresses
grammaire:数据类型 * 变量名；
Exemple
#include<iostream>
using namespace std;
int main()
{
int a = 10;
//指针定义
int *p;
//让指针记录变量a的地址
p = &a;
cout << "a的地址为：" << &a << endl;
cout << "指针p为：" << p << endl;
//可以通过解引用的方式来找到指针指向的内存
//指针前加 * 代表解引用，找到指针指向的内存中的数据
*p = 1000;
cout << "a = " << a << endl;
cout << "*p = " << *p << endl;
system("pause");
return 0;
}
Résultat de sortie
Le déréférencement consiste à renvoyer l'objet correspondant dans l'adresse mémoire
Dans un système d'exploitation 32 bits, un pointeur occupe 4 octets d'espace, quel que soit le type de données
Dans un système d'exploitation 64 bits, le pointeur occupe une taille d'espace octet
Pointeur nul: La variable pointeur pointe vers l'espace numéroté 0 dans la mémoire, qui est utilisé pour initialiser la variable pointeur
Remarque La mémoire pointée par le pointeur nul n'est pas accessible (le numéro de mémoire entre 0 et 255 est occupé par le système, il n'est donc pas accessible)
Pointeur sauvage: La variable pointeur pointe vers un espace mémoire illégal
Les pointeurs nuls et les pointeurs sauvages ne sont pas l'espace pour lequel nous postulons, alors ne visitez pas
1, pointeur modifié par const
-
const pointeur de constante de pointeur modifié
-
const constante de pointeur constant modifiée
-
const modifie à la fois les pointeurs et les constantes
Pointeur constant: Le point du pointeur peut être modifié, mais la valeur pointée par le pointeur ne peut pas être modifiée
const int * p = &a;
int a = 10;
int b = 10;
int *p = &a;
*p = 20; //错误，指针指向的值不可以改
p = &b; //正确，指针指向可以改
Constante du pointeur: Le pointage du pointeur ne peut pas être modifié, la valeur pointée par le pointeur peut être modifiée
int * const p = &a;
int a = 10;
int b = 10;
int *p = &a;
*p = 20; //正确，指针指向的值可以改
p = &b; //错误，指针指向不可以改
const modifie à la fois les pointeurs et les constantes: Le point du pointeur et la valeur pointée par le pointeur ne peuvent pas être modifiés
const int * const p = &a;
2. Pointeurs et tableaux
Utilisez des pointeurs pour accéder au contenu du tableau
Exemple
#include <iostream>
using namespace std;
int main()
{
int arr[9] = {
1,2,3,4,5,6,7,8,9 };
int *p = arr;
for(int i = 0; i < 9; i++)
{
cout << "利用指针输出数组中第" << i + 1<< "个数：" ;
cout << *p << endl;
p++;
}
system("pause");
return 0;
}
Résultat de sortie
3. Pointeurs et fonctions
En utilisant des pointeurs comme paramètres de fonction, vous pouvez modifier la valeur du paramètre réel (transfert d'adresse)
Exemple
#include <iostream>
using namespace std;
//地址传递，与值传递不同，地址传递可以改变主函数中实参的值
void swap(int *p1, int *p2)
{
int temp = *p1;
*p1 = *p2;
*p2 = temp;
}
int main()
{
int a = 10;
int b = 20;
swap(&a, &b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
system("pause");
return 0;
}
Résultat de sortie
3. Pointeurs, tableaux, fonctions
Encapsulez une fonction et utilisez le tri par bulles pour obtenir un tri croissant des tableaux d'entiers
#include<iostream>
using namespace std;
//冒泡排序函数
void bubble(int *arr, int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - i - 1; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
int main()
{
int arr[10] = {
4,6,9,5,3,2,7,8,1,10 };
int len = sizeof(arr) / sizeof(arr[0]);
bubble(arr, len);
for (int i = 0; i < 10; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}
Résultat de sortie
Deuxièmement, la structure
La structure appartient à l'utilisateurPersonnaliserTypes de données, permettant aux utilisateurs de stocker différents types de données
1. Définition et utilisation de la structure
grammaire:struct 结构体名 { 结构体成员列表 }；
Il existe trois façons de créer des variables via des structures:
-
structure nom de la structure nom de la variable
-
structure nom de la structure nom de la variable = {valeur du membre 1, valeur du membre 2 ...}
-
Au fait, créez des variables lors de la définition de la structure
Exemple
#include<iostream>
#include<string>
using namespace std;
struct student
{
string name;
int age;
int score;
}s3; //定义结构体时顺便创建变量
int main()
{
// 1、struct 结构体名 变量名
struct student s1;
s1.name = "张三";
s1.age = 17;
s1.score = 90;
cout << "姓名：" << s1.name << " 年龄：" << s1.age << " 分数：" << s1.score << endl;
// 2、struct 结构体名 变量名 = { 成员1值，成员2值... }
struct student s2 = {
"李四",17,87 };
cout << "姓名：" << s2.name << " 年龄：" << s2.age << " 分数：" << s2.score << endl;
//3、定义结构体时顺便创建变量
s3.name = "王五";
s3.age = 18;
s3.score = 91;
cout << "姓名：" << s3.name << " 年龄：" << s3.age << " 分数：" << s3.score << endl;
system("pause");
return 0;
}
Résultat de sortie
2. Tableau de structure
Placez la structure personnalisée dans la baie pour une maintenance facile
grammaire:struct 结构体名 数组名[ 元素个数 ] = { {}，{}，......}
Exemple
#include<iostream>
#include<string>
using namespace std;
//1、定义结构体
struct student
{
string name;
int age;
int score;
};
int main()
{
//2、创建结构体数组
struct student stu[2]=
{
{
"张三", 18, 95},
{
"李四", 17, 90}
};
//3、给结构体数组中的元素赋值
stu[1].name = "王五";
//4、遍历结构体数组
for (int i = 0; i < 2; i++)
{
cout << "姓名：" << stu[i].name
<< " 年龄：" << stu[i].age
<< " 分数：" << stu[i].score << endl;
}
system("pause");
return 0;
}
Résultat de sortie
3. Pointeur de structure
Accéder aux membres de la structure via le pointeur
Utilisez operator -> pour accéder aux attributs de structure via des pointeurs de structure
== Accédez aux propriétés de la structure via le pointeur de structure, vous devez utiliser '->' ==
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
int main()
{
//创建结构体变量
struct student s = {
"张三", 18, 95 };
//通过指针指向结构体变量
struct student * p = &s;
//通过指针访问结构体变量
cout << "姓名：" << p->name
<< " 年龄：" << p->age
<< " 分数：" << p->score << endl;
system("pause");
return 0;
}
4. Structure structure imbriquée
Exemple
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
struct teacher
{
int id;
string name;
int age;
struct student stu;
};
int main()
{
teacher t;
t.id = 001;
t.name = "老王";
t.age = 50;
t.stu.name = "小王";
t.stu.age = 17;
t.stu.score = 90;
cout << "老师姓名：" << t.name
<< " 老师id：" << t.id
<< " 老师年龄：" << t.age<<endl
<< "学生姓名：" << t.stu.name
<< " 学生年龄：" << t.stu.age
<< " 学生分数：" << t.stu.score << endl;
system("pause");
return 0;
}
5. Structure comme paramètre de fonction
Passer la structure comme paramètre comme une fonction
Méthode de livraison:
-
Passer par valeur
-
Adresse pass
Exemple
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
//打印学生信息
//1、值传递
void print01(struct student s)
{
s.age = 100;
cout << "print01学生姓名：" << s.name
<< " 学生年龄：" << s.age
<< " 学生分数：" << s.score << endl;
}
//2、地址传递
void print02(struct student *p)
{
p->age = 200;
cout << "print02学生姓名：" << p->name
<< " 学生年龄：" << p->age
<< " 学生分数：" << p->score << endl;
}
int main()
{
struct student s;
s.name = "张三";
s.age = 18;
s.score = 90;
print01(s);
cout << "main01学生姓名：" << s.name
<< " 学生年龄：" << s.age
<< " 学生分数：" << s.score << endl;
print02(&s);
cout << "main02学生姓名：" << s.name
<< " 学生年龄：" << s.age
<< " 学生分数：" << s.score << endl;
system("pause");
return 0;
}
Résultat de sortie
6, l'utilisation de const dans la structure
Utilisez const pour éviter un mauvais fonctionnement
Changez les paramètres formels de la fonction en pointeurs, ce qui peut réduire l'espace mémoire et ne plus avoir besoin de faire des copies
Exemple
#include<iostream>
#include<string>
using namespace std;
//定义结构体
struct student
{
string name;
int age;
int score;
};
void print(const student *s)
{
//加入const后，在函数中不可再修改结构体中数据属性
cout << "学生姓名：" << s->name
<< " 学生年龄：" << s->age
<< " 学生分数：" << s->score << endl;
}
int main()
{
struct student s = {
"张三",20,90 };
//通过函数来打印结构体信息
print(&s);
system("pause");
return 0;
}
[Note] Le cours d’apprentissage est le didacticiel C ++ du programme Dark Horse