Table des matières
1. Sélectionnez la structure :
3. Instruction de commutation :
Deuxièmement, la structure du cycle :
1. instruction de boucle while
2. instruction de boucle do...while
3. pour l'instruction de la boucle
1. Définition de la fonction :
3. Transfert de valeur et transfert d'adresse :
6. Fonction d'écriture de fichier :
1. Sélectionnez la structure :
1. L'instruction if :
Fonction : Exécute l'instruction qui satisfait la condition. Divisé en trois formes suivantes:
-
Format sur une seule ligne si instruction
-
Format multiligne si instruction
-
instruction if multi-conditionnelle
int main() {
//选择结构-单行if语句
int score = 200;
//if语句
//注意事项，在if判断语句后面，不要加分号
if (score > 600)
{
cout << "我考上了一本大学！！！" << endl;
}
//多行格式if语句
if (score > 600)
{
cout << "我考上了一本大学" << endl;
}
else
{
cout << "我未考上一本大学" << endl;
}
//多条件if语句：
if (score > 600)
{
cout << "我考上了一本大学" << endl;
}
else if (score > 500)
{
cout << "我考上了二本大学" << endl;
}
else if (score > 400)
{
cout << "我考上了三本大学" << endl;
}
else
{
cout << "我未考上本科" << endl;
}
system("pause");
return 0;
}Dans le même temps, C++ prend également en charge le corps if vide, mais un point-virgule est requis ;
int main()
{
if (1 > 0);
system("pause");
return 0;
}2. Opérateur ternaire :
Fonction : Réaliser un jugement simple grâce à l'opérateur ternaire
grammaire:表达式1 ? 表达式2 ：表达式3
int main() {
int a = 10;
int b = 20;
int c = 0;
c = a > b ? a : b;
cout << "c = " << c << endl; //20
//C++中三目运算符返回的是变量,可以继续赋值
(a > b ? a : b) = 100;
cout << "a = " << a << endl; //10
cout << "b = " << b << endl; //100
cout << "c = " << c << endl; //20
system("pause");
return 0;
}3. Instruction de commutation :
Fonction : exécuter des instructions de branche multi-conditionnelles
grammaire:
switch(表达式)
{
case 结果1：执行语句;break;
case 结果2：执行语句;break;
...
default:执行语句;break;
}Remarque 1 : le type d'expression dans l'instruction switch ne peut être qu'un entier ou un caractère
Remarque 2 : S'il n'y a pas de rupture dans le cas, le programme continuera à s'exécuter vers le bas
Résumé : Par rapport à l'instruction if, lors du jugement de plusieurs conditions, la structure du commutateur est claire et l'efficacité d'exécution est élevée. L'inconvénient est que le commutateur ne peut pas juger l'intervalle
nt main() {
//请给电影评分
//10 ~ 9 经典
// 8 ~ 7 非常好
// 6 ~ 5 一般
// 5分以下 烂片
int score = 0;
cout << "请给电影打分" << endl;
cin >> score;
switch (score)
{
case 10:
case 9:
cout << "经典" << endl;
break;
case 8:
cout << "非常好" << endl;
break;
case 7:
case 6:
cout << "一般" << endl;
break;
default:
cout << "烂片" << endl;
break;
}
system("pause");
return 0;
}Deuxièmement, la structure du cycle :
1. instruction de boucle while
Fonction : satisfaire la condition de boucle, exécuter l'instruction de boucle
grammaire:while(循环条件){ 循环语句 }
Explication : == Tant que le résultat de la condition de boucle est vrai, exécutez l'instruction de boucle ==
int main() {
int num = 0;
while (num < 10)
{
cout << "num = " << num << endl;
num++;
}
system("pause");
return 0;
}2. instruction de boucle do...while
Fonction : satisfaire la condition de boucle, exécuter l'instruction de boucle
grammaire: do{ 循环语句 } while(循环条件);
Remarque : La différence avec while est que do...while exécutera d'abord l'instruction dans do une fois, puis jugera si la condition du corps de la boucle est satisfaite, puis décidera s'il faut entrer à nouveau dans le corps de la boucle, et l'instruction do être exécuté qu'une seule fois.
int main() {
int num = 0;
do
{
cout << num << endl;
num++;
} while (num < 10);
system("pause");
return 0;
}3. pour l'instruction de la boucle
Fonction : satisfaire la condition de boucle, exécuter l'instruction de boucle
grammaire:for(起始表达式;条件表达式;末尾循环体) { 循环语句; }
Remarque : Les expressions dans la boucle for doivent être séparées par des points-virgules
int main() {
for (int i = 0; i < 10; i++)
{
cout << i << endl;
}
system("pause");
return 0;
}
3. Tableau :
Le soi-disant tableau est une collection qui stocke des éléments de données du même type
Fonctionnalité 1 : chaque élément de données du tableau est du même type de données
Caractéristique 2 : les baies sont composées d'emplacements de mémoire contigus
1. Tableau unidimensionnel :
Trois façons de définir un tableau unidimensionnel :
-
数据类型 数组名[ 数组长度 ]; -
数据类型 数组名[ 数组长度 ] = { 值1，值2 ...}; -
数据类型 数组名[ ] = { 值1，值2 ...};
int main() {
//定义方式1
//数据类型 数组名[元素个数];
int score[10];
//利用下标赋值
score[0] = 100;
score[1] = 99;
score[2] = 85;
//利用下标输出
cout << score[0] << endl;
cout << score[1] << endl;
cout << score[2] << endl;
//第二种定义方式
//数据类型 数组名[元素个数] = {值1，值2 ，值3 ...};
//如果{}内不足10个数据，剩余数据用0补全
int score2[10] = { 100, 90,80,70,60,50,40,30,20,10 };
//逐个输出
//cout << score2[0] << endl;
//cout << score2[1] << endl;
//一个一个输出太麻烦，因此可以利用循环进行输出
for (int i = 0; i < 10; i++)
{
cout << score2[i] << endl;
}
//定义方式3
//数据类型 数组名[] = {值1，值2 ，值3 ...};
int score3[] = { 100,90,80,70,60,50,40,30,20,10 };
for (int i = 0; i < 10; i++)
{
cout << score3[i] << endl;
}
system("pause");
return 0;
}Utilisation de noms de tableaux 1D :
-
Peut compter la longueur de l'ensemble du tableau en mémoire
-
Vous pouvez obtenir la première adresse du tableau en mémoire
-
Le nom du tableau est une constante et ne peut pas être attribué
-
Imprimez directement le nom du tableau, vous pouvez voir la première adresse de la mémoire occupée par le tableau
-
Effectuez sizeof sur le nom du tableau pour obtenir la taille de l'espace mémoire occupé par l'ensemble du tableau
int main() {
//数组名用途
//1、可以获取整个数组占用内存空间大小
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
cout << "整个数组所占内存空间为： " << sizeof(arr) << endl;
cout << "每个元素所占内存空间为： " << sizeof(arr[0]) << endl;
cout << "数组的元素个数为： " << sizeof(arr) / sizeof(arr[0]) << endl;
//2、可以通过数组名获取到数组首地址
cout << "数组首地址为： " << (int)arr << endl; //也就是arr[0]的地址
cout << "数组中第一个元素地址为： " << (int)&arr[0] << endl;
cout << "数组中第二个元素地址为： " << (int)&arr[1] << endl;
//arr = 100; 错误，数组名是常量，因此不可以赋值
system("pause");
return 0;
}2. Tri à bulles :
Fonction : L'algorithme de tri le plus couramment utilisé, triant les éléments du tableau
-
Comparez les éléments adjacents. Si le premier est plus grand que le second, échangez-les tous les deux.
-
Faites de même pour chaque paire d'éléments adjacents, et lorsque vous avez terminé, trouvez la première valeur maximale.
-
Répétez les étapes ci-dessus, chaque fois que le nombre de comparaisons -1, jusqu'à ce qu'aucune comparaison ne soit requise
int main() {
int arr[9] = { 4,2,8,0,5,7,1,3,9 };
int len = sizeof(arr) / sizeof(arr[0]);
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
if (arr[j] > arr[j + 1])
{
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
//打印数据
for (int i = 0; i < 9; i++)
{
cout << arr[i] << endl;
}
system("pause");
return 0;
}2. Tableau bidimensionnel :
Quatre façons de définir un tableau à deux dimensions :
-
数据类型 数组名[ 行数 ][ 列数 ]; -
数据类型 数组名[ 行数 ][ 列数 ] = { {数据1，数据2 } ，{数据3，数据4 } }; -
数据类型 数组名[ 行数 ][ 列数 ] = { 数据1，数据2，数据3，数据4}; -
数据类型 数组名[ ][ 列数 ] = { 数据1，数据2，数据3，数据4};
Lors de la définition d'un tableau à deux dimensions, si les données sont initialisées, le nombre de lignes peut être omis et les colonnes doivent être effacées quelle que soit la méthode de définition
int main() {
//方式1
//数组类型 数组名 [行数][列数]
int arr[2][3];
arr[0][0] = 1;
arr[0][1] = 2;
arr[0][2] = 3;
arr[1][0] = 4;
arr[1][1] = 5;
arr[1][2] = 6;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 3; j++)
{
cout << arr[i][j] << " ";
}
cout << endl;
}
//方式2
//数据类型 数组名[行数][列数] = { {数据1，数据2 } ，{数据3，数据4 } };
int arr2[2][3] =
{
{1,2,3},
{4,5,6}
};
//方式3
//数据类型 数组名[行数][列数] = { 数据1，数据2 ,数据3，数据4 };
int arr3[2][3] = { 1,2,3,4,5,6 };
//方式4
//数据类型 数组名[][列数] = { 数据1，数据2 ,数据3，数据4 };
int arr4[][3] = { 1,2,3,4,5,6 };
system("pause");
return 0;
}Nom du tableau 2D
-
Afficher l'espace mémoire occupé par un tableau à deux dimensions
-
Obtenir la première adresse du tableau à deux dimensions
int main() {
//二维数组数组名
int arr[2][3] =
{
{1,2,3},
{4,5,6}
};
cout << "二维数组大小： " << sizeof(arr) << endl;
cout << "二维数组一行大小： " << sizeof(arr[0]) << endl;
cout << "二维数组元素大小： " << sizeof(arr[0][0]) << endl;
cout << "二维数组行数： " << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组列数： " << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;
//地址
cout << "二维数组首地址：" << arr << endl;
cout << "二维数组第一行地址：" << arr[0] << endl;
cout << "二维数组第二行地址：" << arr[1] << endl;
cout << "二维数组第一个元素地址：" << &arr[0][0] << endl;
cout << "二维数组第二个元素地址：" << &arr[0][1] << endl;
system("pause");
return 0;
}4. Fonction :
1. Définition de la fonction :
1. Type de valeur de retour : Une fonction peut retourner une valeur. dans la définition de la fonction
2. Nom de la fonction : donnez un nom à la fonction
3. Liste des paramètres : lors de l'utilisation de cette fonction, les données
4. Instruction du corps de la fonction : le code entre accolades, l'instruction à exécuter dans la fonction
5. Expression de retour : liée au type de valeur de retour, après l'exécution de la fonction, les données correspondantes seront retournées
grammaire:
返回值类型 函数名 （参数列表）
{
函数体语句
return表达式
}
//函数定义
int add(int num1, int num2)
{
int sum = num1 + num2;
return sum;
}2. Appel de fonction
Fonction : utiliser la fonction définie
grammaire:函数名（参数）
Exemple:
//函数定义
int add(int num1, int num2) //定义中的num1,num2称为形式参数，简称形参
{
int sum = num1 + num2;
return sum;
}
int main() {
int a = 10;
int b = 10;
//调用add函数
int sum = add(a, b);//调用时的a，b称为实际参数，简称实参
cout << "sum = " << sum << endl;
system("pause");
return 0;
}3. Transfert de valeur et transfert d'adresse :
1. Transfert de valeur :
-
Le soi-disant passage par valeur signifie que lorsque la fonction est appelée, le paramètre réel passe la valeur au paramètre formel.
-
Lors du passage par valeur, si le paramètre formel se produit, cela n'affectera pas le paramètre réel
2. Adresse de livraison :
-
Le soi-disant passage d'adresse signifie que le paramètre réel est passé au paramètre formel lorsque la fonction est appelée.
-
Lorsque l'adresse est passée, si le paramètre formel se produit, le paramètre réel changera également
#include<iostream>
using namespace std;
#pragma warning(disable:4996)
void swap(int num1, int num2)
{
num1 = 20;
num2 = 10;
}
void swap_address(int &num1, int &num2) {
num1 = 20;
num2 = 10;
}
int main() {
int a = 10;
int b = 20;
swap(a, b);
cout << "mian中的 a = " << a << endl; //10
cout << "mian中的 b = " << b << endl; //20
swap_address(a, b);
cout << "mian中的 a = " << a << endl; //20
cout << "mian中的 b = " << b << endl; //10
system("pause");
return 0;
}
4. Styles communs de fonctions
1. Pas de retour sans participation 2. Pas de retour avec participation
3. Retour sans participation 3. Retour avec participation
//函数常见样式
//1、 无参无返
void test01()
{
//void a = 10; //无类型不可以创建变量,原因无法分配内存
cout << "this is test01" << endl;
//test01(); 函数调用
}
//2、 有参无返
void test02(int a)
{
cout << "this is test02" << endl;
cout << "a = " << a << endl;
}
//3、无参有返
int test03()
{
cout << "this is test03 " << endl;
return 10;
}
//4、有参有返
int test04(int a, int b)
{
cout << "this is test04 " << endl;
int sum = a + b;
return sum;
}5. Déclaration de fonction
Fonction : Indiquez au compilateur le nom de la fonction et comment appeler la fonction. Le corps réel de la fonction peut être défini séparément.
-
Une fonction peut être déclarée plusieurs fois , mais une fonction ne peut être définie qu'une seule fois
Exemple:
//声明可以多次，定义只能一次
//声明
int max(int a, int b);
int max(int a, int b);
//定义
int max(int a, int b)
{
return a > b ? a : b;
}
int main() {
int a = 100;
int b = 200;
cout << max(a, b) << endl;
system("pause");
return 0;
}6. Fonction d'écriture de fichier :
Fonction : Pour rendre la structure du code plus claire, il y a généralement 4 étapes dans l'écriture :
-
Créez un fichier d'en-tête avec le suffixe .h
-
Créer un fichier source avec un suffixe .cpp
-
Écrire des déclarations de fonction dans les fichiers d'en-tête
-
Ecrire la définition de la fonction dans le fichier source
Trois fichiers, le premier fichier .h est utilisé pour déclarer la fonction. Le deuxième fichier .cpp est utilisé pour définir le corps de la fonction. Le troisième fichier de fonction principale est utilisé.
Exemple:
//swap.h文件
#include<iostream>
using namespace std;
//实现两个数字交换的函数声明
void swap(int a, int b);//swap.cpp文件
#include "swap.h"
void swap(int a, int b)
{
int temp = a;
a = b;
b = temp;
cout << "a = " << a << endl;
cout << "b = " << b << endl;
}//main函数文件
#include "swap.h"
int main() {
int a = 100;
int b = 200;
swap(a, b);
system("pause");
return 0;
}