Connaissance de base du langage C
- 1. Calcul
- 2. Jugement et cycle
- 3. Cycle ultérieur et jugement
- 4. Contrôle de boucle
- 5. Tableaux et fonctions
-
- 1. Tableau :
- 2. Définition et utilisation des fonctions
- 3. Paramètres de fonction et variables
- 4. Tableau bidimensionnel
- 6. Opérations sur les tableaux
- 7. Pointeurs et chaînes
-
- 1. Pointeur
- 2. Type de caractère
- 3. Chaîne
- 4. Calcul de chaîne
1. Calcul
1. Calculer la monnaie ~ Idée + code
【Réflexions】 :
① Il y a un endroit pour mettre les nombres d'entrée ;
② Il y a un moyen d'entrer les nombres ;
③ Les nombres d'entrée peuvent participer au calcul.
[Code]:
#include <stdio.h>
int main()
{
int price = 0; // 定义了整型变量price --- 变量是保存数据的地方；变量的名字是一种“标识符”
// 标识符只能由字母、数字和下划线组成，数字不能出现在第一个位置上
printf("请输入金额（元）：");
scanf("%d", &price); // 注意price前面的 & ；
int change = 100 - price;
printf("找您%d元。\n", change);
return 0;
}
【Note：】
1. Une variable est un endroit pour enregistrer des données, le nom d'une variable est une sorte d'"identifiant"
2. Un identifiant ne peut être composé que de lettres, de chiffres et de traits de soulignement, et les chiffres ne peuvent pas apparaître en première position ;
2. fonction scanf
1. Fonction : entrée
2, par ex.
scanf("%d",&price);
注意：
① Dans scanf, il y en a un avant le prix ② "%d", indiquant que scanf veut lire un entier et le passer à la variable suivante ; "% &lf ", indiquant qu'il veut lire un nombre à virgule flottante ; ③ La chaîne de format qui apparaît dans scanf Les choses dans sont des choses qui doivent être saisies.
3. Constantes et variables
(1) Constantes :
1. par exemple programme principal :
const int AMOUNT = 100;
int price = 0;
printf("请输入金额（元）：");
scanf("%d", &price); // 注意price前面的 & ；
int change = AMOUNT - price;
printf("找您%d元。\n", change);
2. const est un modificateur, ajouté avant int. Après initialisation, il ne peut plus être modifié, c'est-à-dire qu'il ne peut plus être affecté ;
(2) variables :
3. Laissez l'utilisateur saisir la variable MONTANT au lieu d'utiliser une valeur initiale fixe
[programme principal] :
int amount = 100;
int price = 0; // 定义了整型变量price --- 变量是保存数据的地方；变量的名字是一种“标识符”
// 标识符只能由字母、数字和下划线组成，数字不能出现在第一个位置上
printf("请输入金额（元）：");
scanf("%d", &price); // 注意price前面的 & ；
printf("请输入票面：");
scanf("%d",&amount);
int change = amount - price;
printf("找您%d元。\n", change);
【Résultat de l'opération】 :
4. Lisez les valeurs de deux variables et additionnez-les pour obtenir le résultat :
【Code】 :
int a;
int b;
printf("请输入两个整数：");
scanf("%d %d",&a,&b);
printf("%d + %d = %d\n",a,b,a+b);
【résultat de l'opération】 :
4. Nombres à virgule flottante
(1) Programme de calcul de hauteur
1. Le résultat de l'opération de deux nombres entiers ne peut être qu'un nombre entier ;
par exemple, 10/3*3 = 9
2. 浮点数—— La virgule décimale est flottante ;
3. Lorsqu'un nombre entier et un nombre à virgule flottante sont mis ensemble pour l'opération, C utilisera l'entier Convertir en nombres à virgule flottante, puis effectuera des opérations à virgule flottante ;
① Convertir les pieds et les pouces en mètres
[Code]:
#include <stdio.h>
int main()
{
printf("请分别输入身高的英尺和英寸，"
"如输入\"5 7\"表示5英尺7英寸：");
int foot;
int inch;
scanf("%d %d", &foot, &inch);
printf("身高是%f米。\n",
((foot + inch / 12.0) * 0.3048));
return 0;
}
【résultat de l'opération】 :
② Convertir les centimètres en pieds et en pouces
#include<stdio.h>
int main(){
int foot,inch;
int cm;
float m,t;
scanf("%d",&cm);
m = cm/100.0;
// foot + inch / 12 = m/0.3048;
t = m/0.3048;
// foot = t的整数部分；
// inch = t的小数部分*12
foot = t;
inch = (t - foot)*12;
printf("%d %d",foot,inch);
return 0;
}
4. 双精度浮点数 double
[Code] :
#include <stdio.h>
int main()
{
printf("请分别输入身高的英尺和英寸，"
"如输入\"5 7\"表示5英尺7英寸：");
double foot;
double inch;
scanf("%lf %lf", &foot, &inch); // lf 来表达输入的事 double 类型
printf("身高是%f米。\n",
((foot + inch / 12) * 0.3048));
return 0;
}
Le résultat courant est le même que ci-dessus.
(2) Résumé :
1. Integer int : utilisé à la fois pour l'entrée et la sortie%d ;
printd("%d",...);
scanf("%d",...);
2. Nombres avec décimales :
double
printf("%f",...);
scanf("lf",...);
5. Expression
(1) Calculez le décalage horaire :
【Réflexions】 :
1. Quelles variables doivent figurer dans le programme, et comment lire et exprimer les données pour ces variables ;
2. Comment calculer après avoir obtenu les données ;
【Code】 :
#include <stdio.h>
int main()
{
int hour1,minute1;
int hour2,minute2;
int t1,t2,t;
scanf("%d %d",&hour1,&minute1);
scanf("%d %d",&hour2,&minute2);
t1 = hour1 * 60 + minute1; // 转换成以分钟为单位
t2 = hour2 * 60 + minute2;
t = t2 - t1;
printf("时间差是%d小时%d分", t/60, t%60 ); // t/60 -- 小时部分, t%60 -- 分钟部分
return 0;
}
【résultat de l'opération】 :
(2) Calculer la moyenne de deux nombres
【Réflexions】 :
1. Quel type de variables existe-t-il pour enregistrer la lecture ?
2. Comment calculer ;
[Code]:
#include <stdio.h>
int main()
{
int a,b;
double c;
scanf("%d %d",&a,&b);
c = (a + b) / 2.0;
printf("%d和%d的平均值=%lf\n",a,b,c);
return 0;
}
【résultat de l'opération】 :
(3) Priorité des opérateurs
1. Le fonctionnement monoculaire n'a qu'un seul opérateur. par exemple -a ;
2. Les opérateurs unaires ont une priorité plus élevée que la multiplication et la division :
par exemple.
a*-b; // 先算-b，再与a相乘；
3. Même priorité - de gauche à droite → combinaison ;
[Exception] : opérateur unaire, opération d'affectation - combinaison de droite à gauche ;
4. [Exemple] :
10 + 9 * ((8 + 7) % 6) + 5 * 4 % 3 * 2 + 3 // 44
1 + 2 + (3 + 4) * ((5 * 6 % 7 / 8) - 9) * 10 //-627
5. Mission intégrée :
int a = 6;
int b;
int c = 1 + (b=a);
Inconvénients : peu propice à la lecture, sujet aux erreurs ;
6. Exemple :
result = a = b = c + 3; // 先算3+c，再赋给b，再赋给a，再赋给result；
result = (result = result * 2)*6*(result = 3+result); //最好不要用嵌入式赋值！！要拆开几个表达式
(4) Variables d'échange
【programme】:
#include <stdio.h>
int main()
{
int a,b;
int c;
printf("请输入a与b的值:");
scanf("%d %d",&a,&b);
c = a;
a = b;
b = c;
printf("a=%d,b=%d\n",a,b);
return 0;
}
【résultat de l'opération】 :
(5) Opérateurs composites
① Affectation composée
1. Y compris +=, -=, *=, /=, %=.
2. par ex.
total += 5; // total = total + 5
total *= sum + 12; // total = total * (sum + 12) --- 先把右侧算完，再与total计算
② Opérateurs d'incrémentation et de décrémentation
1. Forme : ++; --. est un opérateur unaire.
2. Tels que :
count ++; // count += 1 ;即 count = count + 1
a++; // a++的值是a加1以前的值
++a; //++a 的值是加了1以后的值
3. Procédure de cas
#include <stdio.h>
int main()
{
int a=10;
printf("a++ =%d\n",a++);
printf("a = %d\n",a);
printf("++a = %d\n",++a);
printf("a = %d\n",a);
return 0;
}
6. Cas de programme - trois chiffres dans l'ordre inverse
(1) Contenu de la rubrique :
nombres à trois chiffres dans l'ordre inverse :
le programme lit à chaque fois un nombre positif à trois chiffres, puis affiche les nombres dans l'ordre inverse. Notez que lorsque le nombre d'entrée contient un 0 à la fin, la sortie ne doit pas avoir de 0 au début. Par exemple, si vous saisissez 700, la sortie doit être 7.
Astuce : Utilisez %10 pour obtenir des chiffres uniques, utilisez /100 pour obtenir des centaines de chiffres... Combinez les trois nombres ainsi obtenus : centaines de 100 + dizaines de 10 + unités, et le résultat est obtenu.
[Code]:
#include <stdio.h>
int main()
{
int a;
printf("请输入一个三位数：");
scanf("%d",&a);
printf("逆序数 = %d\n", (a%10)*100+(((a-(a/100)*100)/10)*10)+a/100);
// 得到十位数的方法也可以是：① a%100，再/10 ；或 ② a/10 再 %10
return 0;
}
2. Jugement et cycle
1, jugement
(1) Programme d'initiation
#include <stdio.h>
int main()
{
int hour1,minute1;
int hour2,minute2;
int ih,im;
scanf("%d %d",&hour1,&minute1);
scanf("%d %d",&hour2,&minute2);
ih = hour2 - hour1;
im = minute2 - minute1;
if(im<0){
im = 60+im;
ih --;
}
printf("时间差是%d小时%d分", ih, im );
return 0;
}
Le résultat courant est correct.
(2) Le langage C fournit six opérateurs relationnels :
== 相等
!= 不相等
> 大于
>= 大于或等于
< 小于
<= 小于或等于
Note：
Il n'y a que deux résultats d'opérations relationnelles : si la relation est établie, le résultat est 1 ; sinon, il est 0.
① Priorité
1. La priorité de tous les opérateurs relationnels est inférieure à celle des opérations arithmétiques, mais supérieure à celle des opérations d'affectation.
printf("%d", 7>=3+4 ); // 运行结果 = 1
2. La priorité de juger s'ils sont égaux ==ou non est inférieure à celle des autres, et les opérations relationnelles continues sont combinées [de gauche à droite].！=
printf("%d", 6>5>4 ); // 运行结果 = 0
printf("%d", 5>3 == 6>4 ); // 运行结果 = 1
printf("%d", a == b == 6 ); //从左到右
(3) Change Calculator - Optimisation
#include <stdio.h>
int main()
{
// 初始化
int price = 0;
int bill = 0;
//读入金额和票面
printf("请输入金额：");
scanf("%d", &price);
printf("请输入票面：");
scanf("%d", &bill);
// 计算找零
if(bill>=price)
printf("应该找您：%d\n", bill - price);
else
printf("你的钱不够\n");
return 0;
}
(4) Calculer le salaire :
#include <stdio.h>
int main()
{
const double RATE = 8.25; // 每小时的薪水
const int STANDARD = 40; // 一周的标准工作时间
double pay = 0.0;
int hours;
printf("请输入工作的小时数: ");
scanf("%d", &hours);
printf("\n");
if (hours > STANDARD)
pay = STANDARD * RATE + (hours-STANDARD) * (RATE * 1.5);
else
pay = hours * RATE;
printf("应付工资: %f\n", pay);
return 0;
}
(5) Juger les résultats
#include <stdio.h>
int main()
{
const int PASS=60;
int score;
printf("请输入成绩: ");
scanf("%d", &score);
printf("你输入的成绩是%d.\n", score);
if ( score < PASS )
printf("很遗憾，这个成绩没有及格。");
else {
printf("祝贺你，这个成绩及格了。");
printf("再见\n");
}
return 0;
}
2. Faire du vélo
(1) Déterminer le nombre de chiffres
① Quatre chiffres et moins :
#include<stdio.h>
int main()
{
int x;
int n = 1;
scanf("%d",&x);
if(x>999)
n = 4;
else if (x > 99)
n = 3;
else if(n > 9)
n = 2;
else
n = 1;
printf("%d\n",n);
return 0;
}
② Optimisation - instruction de boucle
#include<stdio.h>
int main()
{
int x;
int n = 0;
scanf("%d",&x);
n++;
x /= 10;
while (x > 0){
n++ ;
x /= 10;
}
printf("%d\n",n);
return 0;
}
【Note】：Dans le programme, ++n; x/=10; ne peut pas être entièrement écrit dans l'instruction de boucle while. Puisque x = 0, n devrait = 1.
(2) boucle do-while
do
{
<循环体语句>
}while(<循环条件>);
【note】：
1. Indépendamment du fait que les conditions soient remplies ou non, do-while recommencera sans aucun doute, tant que les conditions ne seront pas remplies, rien ne sera fait.
③ Optimisation de la boucle Do-while
#include<stdio.h>
int main()
{
int x;
int n = 0;
scanf("%d",&x);
do
{
x /= 10;
n++ ;
} while(x > 0);
printf("%d\n",n);
return 0;
}
(3) pour la boucle
① Opération factorielle
1. boucle while
#include<stdio.h>
int main()
{
int n;
int fact = 1;
int i = 1;
scanf("%d",&n);
while(i <= n){
fact *= i;
i++;
}
printf("%d!=%d\n",n,fact);
return 0;
}
2. pour la boucle
#include<stdio.h>
int main()
{
int n;
int fact = 1;
int i = 1;
scanf("%d",&n);
/* 从 1 乘到 n */
//for(i=1; i<=n; i++ ){ // ① 初始条件；② 循环条件；③ 增加步长
// fact *= i;
//}
for(i=n; i>1; i--){
// 从 n 乘到 1
fact *= i;
}
printf("%d!=%d\n",n,fact);
return 0;
}
L'instruction for peut également être écrite comme suit, mais seule la compilation C99 peut être utilisée ;
for( int i=1; i<=n; i++ ){
fact *= i;
}
【note】：Chaque expression de l'instruction for peut être omise ; mais le point-virgule ne peut pas être omis ! et
for(;条件;) == while(条件)
(4) Trois types de conseils de sélection de cycle :
- S'il y a un nombre fixe de fois, utilisez
for; - Si cela doit être fait une fois, utilisez
do_while; - Pour les autres situations
while;
3. Cycle ultérieur et jugement
1. Types et opérations logiques
(1) type booléen
fichier de tête :
#include<stdbool.h>
Ensuite, vous pouvez utiliser bool et true, false
(2) Opération logique
- Le résultat des opérations logiques est seulement 0 ou 1 ;
- Opérateurs :
！NON logique ;&&ET logique ;||OU logique ; - priorité：
! > && > || - Tel que : x∈[4,6], écrivez l'expression de x
!age < 20; // 单目运算符的优先级高于双目运算符，故 ！age 只会 = 0 或1；一定 < 20.
a. Résumé des priorités
- L'affectation est toujours la plus basse et est un peu plus élevée que ou ;
- Les opérations relationnelles sont supérieures aux opérations logiques
(3) Opérateur conditionnel
count = (count > 20)?count-10:count
// 条件？条件满足时的值：条件不满足时的值
- Les opérateurs conditionnels ont une priorité plus élevée que les opérateurs d'affectation, mais plus faible que les autres opérateurs ;
- L'opérateur conditionnel estde droite à gauchecombiné
- Il est préférable de ne pas utiliser d'expressions d'opérations conditionnelles imbriquées, la lisibilité est médiocre !
(4) opérateur virgule
- Utilisé pour concaténer deux expressions avec
右边la valeur de l'autre expression comme résultat. - L'opérateur virgule a la priorité la plus faible.
- virgulede gauche à droitecombiner
- souvent
forutilisé dans
for ( i=0,j=10; i<j; i++,j-- );
2. Jugement de la cascade et de l'imbrication
(1) Si-sinon imbriqué
Ex. Programme - Comparaison de la taille de trois nombres
#include<stdio.h>
#include<stdbool.h>
int main(){
int a,b,c,max;
scanf("%d %d %d",&a,&b,&c);
if(a>b){
if(a>c)
max = a;
else
max = c;
}
else{
if(b>c)
max = b;
else
max = c;
}
printf("The max is %d\n",max);
return 0;
}
【Note】：
- le format en retrait ne peut pas impliquer
elseune correspondance ; - conseils : même s'il n'y a qu'une seule instruction, utilisez-la après if et elsegrandes parenthèses{ }! Facile à comprendre!
(2) Si-sinon en cascade
par exemple fonction par morceaux
int f;
if(x < 0){
f = -1;
}else if(x == 0){
f = 0;
}else{
f = x * 2;
}
3. Succursales multiples
（1）si - sinon si - sinon……
#include<stdio.h>
int main(){
int type;
scanf("%d",&type);
if(type == 1)
printf("你好");
else if(type == 2)
printf("早上好");
else if(type == 3)
printf("晚上好");
else if(type == 4)
printf("再见");
else
printf("啊，什么呀？");
return 0;
}
(2) boîtier de commutation
#include<stdio.h>
int main(){
int type;
scanf("%d",&type);
switch (type){
case 1: // type == 1 时
printf("你好");
break;
case 2:
printf("早上好");
break;
case 3:
printf("晚上好");
break;
case 4:
printf("再见");
break;
default:
printf("啊，什么呀？");
break;
}
return 0;
}
【Note】：
switch(控制表达式){
case 常量:
语句
……
case 常量:
语句
……
default:
语句
……
}
- L'expression de contrôle ne peut être que le résultat de type entier
int; - Une constante peut être une constante ou une expression calculée par une constante ;
- sautera lorsqu'il sera rencontré
break;
4. Cas du programme de cycle
(1) Calcul de boucle - calculer le logarithme de x avec base 2
#include<stdio.h>
/* 计算log 以 2 为底，x 的对数*/
int main(){
int x,t;
int ret = 0;
scanf("%d",&x);
t = x;
while( t > 1 ){
t /= 2;
ret ++;
}
printf("log2 of %d is %d.\n", x, ret);
return 0;
}
(2) Calculer la moyenne
[Exigences] : saisissez une série d'entiers positifs, puis saisissez -1 pour indiquer la fin de l'entrée, puis calculez la moyenne de ces nombres, puis affichez le nombre et la moyenne des nombres d'entrée.
[idées] :
- Variable —> Algorithme —> Organigramme —> Programme
[Code] :
#include<stdio.h>
/* 计算平均数 */
int main(){
int number;
int sum = 0;
int count = 0;
scanf("%d",&number);
while(number != -1){
sum += number;
count ++;
scanf("%d",&number);
}
/* do{
scanf("%d",&number);
if(number != -1){
sum += number;
count++; // count 表明从程序中读入了多少个数据；
}
}while (number != -1);
*/
printf("输入的%d个数的平均数 = %f\n", count, 1.0*sum / count);
return 0;
}
(3) jeu de devinettes
[Exigence] : L'ordinateur pense à un nombre et laisse l'utilisateur le deviner. Chaque fois que l'utilisateur entre une donnée, on lui dit si elle est trop grande ou trop petite jusqu'à ce que l'utilisateur la devine correctement. Enfin, dites-lui combien de fois il a deviné.
[idées] :
- L'ordinateur pense au hasard à un nombre et l'enregistre dans le nombre variable ;
- La variable count responsable du comptage est initialisée à 0 ;
- Laissez l'utilisateur entrer un nombre a ;
- compter++ ;
- Jugez la relation de taille entre le nombre et a, si a est grand, sortez « gros » ; si a est petit, sortez « petit » ;
- cycle de répétition
- Sinon, sortez "devinez juste" et le nombre de fois, et terminez.
[Code]:
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
/* 猜数游戏 */
int main(){
srand(time(0));
int number = rand()%100+1; // 每次 召唤 rand() 就得到一个随机的整数；
// x % n 的结果是 [0,n-1] 的一个整数；
int a = 0;
int count = 0;
printf("我已经想好了一个 1-100 之间的数。\n");
do{
printf("请猜这个 1-100 之间的数：");
scanf("%d",&a);
count ++;
if (a > number){
printf("你猜的数大了。");
}else if(a < number){
printf("你猜的数小了。");
}
}while (a != number);
printf("太好了，你用了%d次就猜到了答案。\n", count);
return 0;
}
【Noter】:
x % nLe résultat est un entier de [0,n-1] ;rand()Obtenez un entier aléatoire à chaque fois que vous l'invoquez ;
【résultat de l'opération】 :
(4) Inversion d'entiers
[idées] :
- L'opération sur un entier
%10peut atteindre des chiffres simples ; - L'opération sur un entier
/10supprime le chiffre unique - ……
[Code]:
#include<stdio.h>
/* 整数求逆 */
int main(){
int x,t;
int digit;
int ret = 0; // 初始时结果为0
/* 此时若输入为 700，则输出为 7 */
scanf("%d",&x);
t = x;
while(x > 0){
digit = x%10;
// printf("%d\n",digit);
ret = ret *10 + digit;
printf("x=%d, digit=%d, ret=%d\n", x, digit, ret);
x /= 10;
}
printf("整数%d的逆=%d。\n", t,ret);
return 0;
}
/* 此时若输入为 700，则输出为 007 */
scanf("%d",&x);
t = x;
while(x > 0){
digit = x%10;
printf("%d",digit);
ret = ret *10 + digit;
//printf("x=%d, digit=%d, ret=%d\n", x, digit, ret);
x /= 10;
}
4. Contrôle de boucle
1. Contrôle de boucle
(1) Routine : déterminer si un nombre est premier
[Exigence] : Lisez un nombre x et jugez si x est un nombre premier.
Nombre premier : nombre qui n'est divisible que par 1 et lui-même, à l'exclusion de 1.
[Code]:
#include<stdio.h>
/* 判断是否是素数 */
int main(){
int x;
int i;
int isPrime = 1; // isPrime = 1，则 x 是素数
scanf("%d",&x);
for (i=2; i<x; i++){
if( x % i == 0){
// 说明不是素数
isPrime = 0;
break; //break; --- 跳出循环 ； continue; --- 跳过这一轮循环，进入下一轮
}
}
if (isPrime == 1){
printf("是素数。\n");
} else {
printf("不是素数。\n");
}
return 0;
}
【Noter】:
- pause ; ---- Sauter hors de la boucle ;
- continuer ; ---- Passer les instructions restantes dans ce cycle et entrer dans le cycle suivant
【ou】:
/* 判断是否是素数 */
int main(){
int x;
int i;
// int isPrime = 1; // isPrime = 1，则 x 是素数
scanf("%d",&x);
for (i=2; i<x; i++){
if( x % i == 0){
// 说明不是素数
// isPrime = 0;
break; //break; --- 跳出循环 ； continue; --- 跳过这一轮循环，进入下一轮
}
}
// if (isPrime == 1){
if (i == x){
printf("是素数。\n");
} else {
printf("不是素数。\n");
}
- Avantages : économise la consommation mémoire des variables du programme.
- Inconvénients : Le programme a deux exigences, l'une doit être lisible par une machine et l'autre doit être lisible par l'homme. Ce type d'approche intelligente, la logique n'est pas claire, et d'autres personnes consommeront plus de cellules cérébrales lors de la lecture du programme, ce qui n'est pas propice à la transplantation, à la maintenance et au travail d'équipe ultérieurs du programme.
2. Cycles multiples
(1) Routine : produire des nombres premiers à moins de 100
[Code]:
#include<stdio.h>
/* 输出 1-100 的素数 */
int main(){
int x;
int i;
int isPrime = 1; // isPrime = 1，则 x 是素数
//scanf("%d",&x);
x = 6;
for (x=2; x<100; x++)
{
for (i=2; i<x; i++){
if( x % i == 0){
// 说明不是素数
isPrime = 0;
break; //break; --- 跳出循环 ； continue; --- 跳过这一轮循环，进入下一轮
}
}
if (isPrime == 1){
printf("%d ",x);
}
}
printf("\n");
return 0;
}
(2) Routine ② : Sortir les 50 premiers nombres premiers
[Code 1] :
#include<stdio.h>
/* 输出前50个素数 */
int main(){
int x;
int i;
int isPrime = 1; // isPrime = 1，则 x 是素数
int cnt = 0; // 计数器
//scanf("%d",&x);
x = 2;
// for (x=2; x<100; x++)
while (cnt < 50)
{
for (i=2; i<x; i++){
if( x % i == 0){
// 说明不是素数
isPrime = 0;
break; //break; --- 跳出循环 ； continue; --- 跳过这一轮循环，进入下一轮
}
}
if (isPrime == 1){
printf("%d ",x);
cnt++;
}
x++;
}
printf("\n");
return 0;
}
[Code 2] :
// for (x=2; x<100; x++)
// while (cnt < 50)
for (x=2; cnt<50; x++)
{
for (i=2; i<x; i++){
if( x % i == 0){
// 说明不是素数
isPrime = 0;
break; //break; --- 跳出循环 ； continue; --- 跳过这一轮循环，进入下一轮
}
}
if (isPrime == 1){
printf("%d ",x);
cnt++;
}
// x++;
}
printf("\n");
(3) Composez des pièces_ Utilisez 1 jiao, 2 jiao, 5 pièces jiao pour constituer un montant inférieur à 10 yuans
【Code ①】：—— Relaisbreak
#include<stdio.h>
/* 凑硬币 _ 用1角、2角、5角的硬币凑出10元以下的金额 */
int main()
{
int x;
int one,two,five;
int exit = 0;
scanf("%d",&x);
for(one=1; one<x*10; one++){
// 1角最多是 x*10个
for(two=1; two < x*10/2; two++){
// 2角最多是 x*10/2 个
for(five=1; five < x*10/5;five++){
if(one + two*2 + five*5 == x*10){
printf("可以用%d个1角+%d个2角+%d个5角得到%d元\n",one,two,five,x);
exit = 1;
break; /* 【接力 break】*/
}
}
if(exit) break; // 相当于 exit ==1；
}
if(exit) break;
}
return 0;
}
【Noter】:
- break and continue ne peut être fait que sur la boucle où il se trouve ;
[Code ②] : - gotodéclaration
- L'instruction goto est très appropriée pour que la boucle interne de plusieurs boucles imbriquées saute directement à la situation la plus externe.
#include<stdio.h>
/* 凑硬币 _ 用1角、2角、5角的硬币凑出10元以下的金额 */
int main()
{
int x;
int one,two,five;
int exit = 0;
scanf("%d",&x);
for(one=1; one<x*10; one++){
// 1角最多是 x*10个
for(two=1; two < x*10/2; two++){
// 2角最多是 x*10/2 个
for(five=1; five < x*10/5;five++){
if(one + two*2 + five*5 == x*10){
printf("可以用%d个1角+%d个2角+%d个5角得到%d元\n",one,two,five,x);
goto out;
}
}
}
}
out:
return 0;
}
3. Cas d'application circulaire
(1) Trouver la somme des n premiers éléments
①f(n)=1+1/2+1/3+…1/n
[Code]:
#include<stdio.h>
/* 求前 n 项和 —— 1+1/2+1/3+…1/n */
int main()
{
int n;
int i;
double sum = 0.0;
scanf("%d",&n);
for (i=1; i<=n; i++){
sum += 1.0/i;
}
printf("f(%d)=%f\n",n,sum);
return 0;
}
② f(n)=1-1/2+1/3-1/4+…+1/n
#include<stdio.h>
/* 求前 n 项和 _f(n)=1-1/2+1/3-1/4+…+1/n */
int main()
{
int n;
int i;
double sum = 0.0;
int sign = 1;
scanf("%d",&n);
for (i=1; i<=n; i++){
sum += sign*1.0/i;
sign = -sign;
}
printf("f(%d)=%f\n",n,sum);
return 0;
}
[ou] : mettre directementle signe est défini comme un type double
Programme principal :
int n;
int i;
double sum = 0.0;
// int sign = 1;
double sign = 1.0;
scanf("%d",&n);
for (i=1; i<=n; i++){
sum += sign/i;
sign = -sign;
}
printf("f(%d)=%f\n",n,sum);
(2) Trouver le plus grand diviseur commun
Méthode ① : énumération
[idées] :
- Soit t 2 ;
- Si u et v sont divisibles par t, notez ce t;
- Après avoir ajouté 1 à t, répétez la deuxième étape jusqu'à ce que t soit égal à u ou v ;
- Alors, le plus grand t jamais enregistré qui peut diviser à la fois u et v est pgcd.
[Code]:
#include<stdio.h>
/* 求最大公约数 */
int main()
{
int a,b;
int min;
int ret;
int i;
scanf("%d %d",&a,&b);
if (a<b){
min = a;
}else {
min = b;
}
for (i=1;i<min;i++){
// 从 1 开始，到 a 和 b 的最小值
if (a%i == 0){
// a 能被 i 整除
if ( b%i == 0){
// b 能被 i 整除
ret = i; // 目前的公约数
}
}
}
printf("%d和%d的最大公约数是%d\n",a, b, ret);
return 0;
}
Loi ② :Rouler et diviser
[idées] :
- Si b est égal à 0, le calcul se termine et a est le plus grand commun diviseur ;
- Sinon, calcule le reste de la division de a par b de telle sorte que a est égal à b et b est égal à ce reste ;
- Retour à la première étape ;
par ex.
a b t // t—— 余数
12 18 12
18 12 6
12 6 0
6 0
[Code]:
#include<stdio.h>
/* 求最大公约数 */
int main()
{
int a,b;
int t;
scanf("%d %d",&a, &b);
while ( b!=0)
{
t = a%b;
a = b;
b = t;
printf("a=%d,b=%d,t=%d\n",a, b, t);
}
printf("gcd=%d.\n", a);
return 0;
}
【résultat de l'opération】 :
(3) Décomposer les entiers dans l'ordre positif
- Entrez un entier non négatif et sortez chaque chiffre de celui-ci dans l'ordre positif ;
- Entrée : 13425
- Sortie : 1 3 4 2 5
Méthode ① : inverser l'ordre d'abord, puis inverser l'ordre
[Code]:
#include<stdio.h>
/* 求最大公约数 —— 先逆序，再逆序，—— 只适用于末尾不是0的数*/
int main()
{
int x,d;
int t = 0;
scanf("%d",&x);
do{
/* 做【逆序】 */
d = x%10;
t = t*10 + d;
x /= 10; // x 右移一位
}while (x>0);
printf("x=%d,t=%d\n",x,t);
x = t;
do{
/* 【再逆序】 */
int d = x%10; // 得到最右边的一位
printf("%d",d);
if (x>=10){
printf(" "); // 使最后一轮时不输出空格
}
x /= 10; // x 右移一位
} while( x>0 );
printf("\n");
return 0;
}
【résultat de l'opération】 :
Méthode ② : Sortie de séquence positive
[idées] :
eg.
x = 13425;
13425 / 10000 --> 1
13425 % 10000 --> 3425
10000 / 10 --> 1000
3425 / 1000 -->3
3425 % 1000 -->435
1000 / 10 -->100
425 / 100 -->4
425 % 100 -->25
100 /10 -->10
25 / 10 -->2
25 % 10 -->5
10 /10 -->1
5 / 1 -->5
5 % 1 -->5
1 /10 -->0
[Code]:
#include<stdio.h>
/* 求最大公约数 —— 正序输出 */
int main()
{
int d,x;
int mask = 1;
int t = 0;
int cnt = 0;
x = 13425;
t = x;
while (x > 9){
// 可以知道 x 的位数
x /= 10;
mask *= 10;
//cnt++;
}
printf("mask = %d\n",mask);
// mask = pow(10,cnt-1); // mask=10^(cnt-1)
do{
d = t / mask;
printf("%d",d);
if( mask >9 ){
printf(" ");
}
t %= mask;
mask /= 10;
// printf("x=%d,mask=%d,d=%d\n",x,mask,d);
}while ( mask >0 );
printf("\n");
return 0;
}
5. Tableaux et fonctions
1. Tableau :
(1) Exemple : Comment écrire un programme pour calculer la moyenne des nombres entrés par l'utilisateur
① Pas besoin d'enregistrer chaque numéro saisi
#include<stdio.h>
int main(){
int x;
double sum = 0;
int cnt = 0;
scanf("%d",&x); // 读入x
while(x != -1){
sum += x;
cnt ++;
scanf("%d",&x); // 读下一个数
}
if(cnt > 0 ){
printf("%f\n",sum / cnt);
}
return 0;
}
② Calculer la moyenne de l'entrée et de la sortie de tous les nombres supérieurs à la moyenne
[idées] :
- Enregistrer les numéros saisis
- Une fois la saisie terminée, calculez la moyenne
- Ensuite, jugez si chaque numéro doit être sorti
【Comment enregistrer beaucoup de numéros】 :
int num1,num2,num3……？
[Déployer]:
int number[100];
scanf("%d",&number[i]);
[Code]:
#include<stdio.h>
int main(){
int x;
double sum = 0;
int cnt = 0;
int number[100]; // 定义名为number的数组：数组里的每个单元都是 int；数组大小是100个。
scanf("%d",&x);
while(x != -1){
number[cnt] = x; // 对数组中的元素赋值
//
{
int i;
for ( i=0; i<=cnt; i++){
printf("%d\t",number[i]);
}
printf("\n");
}
//
sum += x;
cnt ++;
scanf("%d",&x);
}
if( cnt > 0 ){
// printf("%f\n", sum/cnt);
int i;
double average = sum/cnt;
for( i=0; i<cnt; i++ ){
if (number[i] > average) {
// 使用数组中的元素
printf("%d",number[i]); // 遍历数组中的元素
}
}
}
return 0;
}
(2) Définir un tableau
<类型> 变量名称[元素变量];
如： int grades[100];
double weight[20];
【Note】：
- Le nombre d'éléments doit être un entier ;
- Avant C99 : le nombre d'éléments doit être une valeur littérale déterminée au moment de la compilation
- Des tableaux de longueur 0 - peuvent exister, mais sont inutiles int a[0];
[Caractéristiques du tableau] :
- tous les éléments ont le même type de données ;
- Une fois créée, la taille ne peut pas être modifiée ;
- * (Les éléments du tableau sont disposés consécutivement en mémoire)
- peut apparaître à gauche ou à droite d'un devoir ;
- Sur le côté gauche/droit d'une affectation s'appelle une valeur gauche/droite
- Chaque cellule du tableau est une variable de type tableau ;
- Lors de l'utilisation d'un tableau,
[]le nombre qui y est placé est appelé indice ou index, et l'indice commence à compter à partir de 0 ;
int a[10];
// 10个单元： a[0],a[1],……,a[9]
a[2] = a[1] + 6; // 把a[1]的值读出来，加上6后，写入到a[2]中去；
【Remarque】 :
plage d'indices valide :
- Une fois le programme en cours d'exécution, l'accès à la baie hors limites peut causer des problèmes et provoquer le blocage du programme
- défaut de segmentation
[Procédure de cas] :
#include<stdio.h>
void f();
int main()
{
f();
return 0;
}
void f()
{
int a[10];
a[10] = 0; // a[10] 不是有效下标
}
Optimisation du programme :
Problème : Le programme précédent est dangereux car les données d'entrée peuvent être supérieures à 100.
Optimisation : si vous laissez d'abord l'utilisateur entrer le nombre de nombres à calculer, vous pouvez utiliser la nouvelle fonction de C99 pour y parvenir.
(3) Utiliser des tableaux pour les calculs de hachage
[Cas] :
écrire un programme, entrer un nombre incertain d'entiers dans la plage [0,9], compter le nombre d'occurrences de chaque nombre, entrer -1 pour indiquer la fin
【programme】:
#include<stdio.h>
int main(void)
{
const int number = 10; // 数组的大小
int x;
int count[number]; // count[i] 说明 i 这个数字出现了多少次
int i;
for( i=0; i<number; i++) {
// 初始化数组
count[i] = 0;
}
scanf("%d",&x);
while ( x!= -1 ){
if ( x>=0 && x<=9 ){
count[x] ++; // 运算
}
scanf("%d",&x);
}
for ( i=0; i<number; i++){
// 遍历数组
printf("%d:%d\n", i, count[i] ); // i 这个数字出现了多少次
}
return 0;
}
2. Définition et utilisation des fonctions
(1) Trouver la somme des nombres premiers
#include<stdio.h>
int main(void)
{
int m,n;
int sum = 0;
int cnt = 0;
int i;
scanf("%d %d",&m,&n);
// m=10,n=31;
if(m==1) m=2;
for ( i=m; i<=n; i++){
//判断 i是不是素数
int isPrime = 1;
int k;
for(k=2; k<i-1;k++){
if(i%k == 0){
isPrime = 0;
break;
}
}
if(isPrime){
sum += i;
cnt++;
}
}
printf("%d %d\n",cnt,sum);
return 0;
}
Optimisation : appels de fonctions
#include<stdio.h>
int isPrime(int i ) // 定义的函数
{
int ret = 1;
int k;
for(k=2; k<i-1;k++){
if(i%k == 0){
ret = 0;
break;
}
}
return ret;
}
int main(void)
{
int m,n;
int sum = 0;
int cnt = 0;
int i;
scanf("%d %d",&m,&n);
// m=10，n=31;
if(m==1) m=2;
for ( i=m; i<=n; i++){
//判断 i是不是素数
if(isPrime(i)){
sum += i;
cnt++;
}
}
printf("%d %d\n",cnt,sum);
return 0;
}
(2) Sommation : trouver les trois sommes de 1 à 10, 20 à 30 et 35 à 45
#include<stdio.h>
int main()
{
int i;
int sum;
for( i=1,sum=0; i<=10; i++ ){
sum += i;
}
printf("%d到%d的和是%d\n",1,10,sum);
for( i=20,sum=0; i<=30; i++ ){
sum += i;
}
printf("%d到%d的和是%d\n",20,30,sum);
for( i=35,sum=0; i<=45; i++ ){
sum += i;
}
printf("%d到%d的和是%d\n",35,45,sum);
return 0;
}
注意：La duplication de code est un signe de mauvaise qualité du programme.
Optimisation : fonction de somme
#include<stdio.h>
void sum(int begin, int end)
{
int i;
int sum = 0;
for( i=begin; i<=end; i++){
sum += i;
}
printf("%d到%d的和是%d\n",begin,end,sum);
}
int main()
{
sum(1,10);
sum(20,30);
sum(35,45);
return 0;
}
(3) Qu'est-ce qu'une fonction ?
Une fonction est un bloc de code qui prend zéro ou plusieurs arguments, fait une chose et renvoie zéro ou une valeur.
void sum(int begin, int end)—— en-tête de fonction{}À l'intérieur -- corps de fonctionsum-- Nom de la fonctionvoid—— return type void type ne renvoie pas de résultat()Intérieur - tableau des paramètres
① Fonction d'appel
- nom de la fonction (valeur du paramètre) ;
- () joue un rôle important dans la représentation des appels de fonction
- require() même sans arguments
- La fonction sait où elle est appelée à chaque fois et revient au bon endroit.
(4) Retour de la fonction
Exemple 1:
Dans l'exemple de somme première ci-dessus :
int isPrime(int i ) // 定义的函数
{
int ret = 1;
int k;
for(k=2; k<i-1;k++){
if(i%k == 0){
ret = 0;
break;
}
}
return ret;
}
注意：
- Si la fonction renvoie un résultat, elle doit
returntransmettre ce résultat à l'appelant. - La fonction ci-dessus
isPrimerenverra unintrésultat de type
Exemple 2 :
int max(int a, int b)
{
int ret;
if (a>b){
ret = a;
}else (
ret = b;
)
return ret;
}
Ou : (mais de préférence celui du dessus !)
int max(int a, int b)
{
// int ret;
if (a>b){
return a;
}else {
return b;
}
// return ret;
}
Bien que le second type ne soit pas erroné, il n'est pas conforme au concept d'exportation unique ;
注意：
-
Une fois rencontrée
return, elle va ①arrêter l'exécution de la fonction, ②et renvoyer une valeur ; -
Deux manières d'écrire :
-
return; -
return 表达式; -
returnPlusieurs instructions peuvent apparaître dans une fonction
comme:
#include<stdio.h>
int max(int a, int b)
{
int ret;
if (a>b){
ret = a;
}else {
ret = b;
}
return ret;
}
int main()
{
int a,b,c;
a = 5;
b = 6;
c = max(10,12);
c = max(a,b);
c = max(c, 23);
printf("%d\n",max(a,b));
return 0;
}
① Fonctions sans valeur de retour :
void 函数名(参数表);- Impossible d'utiliser la valeur
return - ne peut pas
return - Vous ne pouvez pas attribuer de valeur de retour lors de l'appel
- Avis: Si la fonction retourne une valeur, vous devez utiliser le
return
3. Paramètres de fonction et variables
(1) Prototype de fonction
- Écrivez la fonction au-dessus de main() - car le compilateur C analyse le code séquentiellement de haut en bas !
- Ou, pour être plus intuitif, vous pouvez le modifier comme ceci :
#include<stdio.h>
void sum(int begin, int end); // 函数的【原型声明declaration】
int main()
{
sum(1,10); // 如没有 声明，会猜测 int sum(int,int)
sum(20,30);
sum(35,45);
return 0;
}
void sum(int begin, int end) // 函数 定义
{
int i;
int sum = 0;
for( i=begin; i<=end; i++){
sum += i;
}
printf("%d到%d的和是%d\n",begin,end,sum);
}
- L'en-tête de la fonction, se terminant par un point-virgule, constitue le prototype de la fonction ;
- Le but du prototype de fonction est de dire au compilateur à quoi ressemble la fonction ①nom, ②paramètres (nombre et type), ③type de retour ;
- L'ancien standard écrivait le prototype de la fonction dans la fonction qui l'appelait ;
- Maintenant, il est généralement écrit devant la fonction
- Le nom du paramètre peut ne pas être écrit dans le prototype, mais il est généralement encore écrit ;
(2) Passage de paramètres
- La valeur qui peut être passée à une fonction est le résultat d'une expression, cela inclut
① 字面量[eg.10]、
② 变量[eg.a]、
③ 函数的返回值[eg.max(23,45)]、
④ 计算的结果[eg.23+45]；
- Si la fonction a des paramètres, il faut lui transmettre le nombre et le type de valeur corrects lors de l'appel de la fonction ;
- Lors de l'appel d'une fonction en langage C,Vous ne pouvez transmettre des valeurs qu'aux fonctions !
- Chaque fonction possède son propre espace de variables, et les paramètres sont également situés dans cet espace indépendant, qui n'a rien à voir avec les autres fonctions !
- Auparavant, les paramètres de la table des paramètres de la fonction s'appelaient "
形式参数" ; la valeur donnée lors de l'appel de la fonction s'appelait "实际参数" ; - Maintenant, nous
形参appelons参数;实参appelons值;
(3) Variables locales
- Chaque fois que la fonction s'exécute, un espace de variables indépendantes est généré, et les variables de cet espace sont uniques à cette exécution de la fonction, appelée
本地变量; - Les variables définies à l'intérieur d'une fonction sont des variables locales ;
- Les paramètres sont également des variables locales ;
① Durée de vie et portée variables
- Durée de vie : quand cette variable commence-t-elle à apparaître et quand meurt-elle ;
- Portée : dans quelle portée de code cette variable est-elle accessible (cette variable peut fonctionner );
- Pour les variables locales, la réponse aux deux questions est uniforme :accolades intérieures - bloc
② Règles pour les variables locales
- Les variables locales sont définies dans un bloc (entre accolades) ;
1.它可以是定义在 函数的块 内；
2.也可以定义在 语句的块 内
- Avant que le programme n'entre dans ce bloc, les variables qu'il contient n'existent pas ;
- Quittez le bloc et les variables qu'il contient disparaissent
- Les variables définies en dehors du bloc sont toujours valides à l'intérieur ;
- Si une variable avec le même nom que l'extérieur est définie à l'intérieur du bloc, elle couvrira l'extérieur
- Une variable portant le même nom ne peut pas être définie dans un bloc
- Les variables locales ne sont pas initialisées par défaut
- Les paramètres sont initialisés lors de l'entrée dans la fonction !
(4) Autres détails
① Lorsqu'il n'y a pas de paramètre
√ void f(void); // 在参数表里放了 void，明确的告诉编译器，这个函数不接收任何参数；
还是？
× void f(); // 在传统C中，它表示 f函数的参数表未知，并不表示没有参数
② opérateur virgule
- Quelle est la différence entre une virgule et l'opérateur virgule lors de l'appel d'une fonction ?
- Les virgules entre parenthèses lors de l'appel d'une fonction sont des signes de ponctuation, pas des opérateurs
f(a,b) // 是标点
f((a,b)) // 是运算符
// 二者区别：到底是传了2个还是1个参数进去
③ Fonctions dans les fonctions
- Le langage C n'autorise pas la définition imbriquée de fonctions
- Vous pouvez mettre la [déclaration] d'une autre fonction dans une fonction, mais vous ne pouvez pas mettre la [définition] d'une autre fonction
4. Tableau bidimensionnel
(1) Tableau à deux dimensions :
int a[3][5]; // 通常理解为a是一个3行5列的矩阵
① Traversée d'un tableau à deux dimensions
- Double boucle
- La couche externe traverse le numéro de ligne ; la couche interne traverse le numéro de colonne
- comme:
for ( i=0; i<3; i++){
for ( j=0; j<5; j++ ){
a[i][j] = i*j;
}
}
a[i][j]Indique la cellule à la ligne i et à la colonne ja[i,j]est une expression
(2) Initialisation d'un tableau à deux dimensions
int a[][5] = {
{
0,1,2,3,4}, // 看做 5个int的数组，作为 a[0];
{
2,3,4,5,6}, // 5个int的数组，作为a[1];
};
- Le nombre de colonnes est requis, le nombre de lignes peut être compté par le compilateur ;
- Un {} par ligne, séparé par des virgules
- S'il est omis, cela signifie un remplissage avec des zéros
- L'orientation peut également être utilisée (*C99 UNIQUEMENT)
(3) jeu de tic-tac-toe (tic-tac-toe)
- Lu dans une matrice 3×3, le nombre dans la matrice est 1, ce qui signifie qu'il y a un X à la position, et 0 signifie O ;
- Le programme juge s'il y a une partie gagnante dans cette matrice et sort le caractère X ou O représentant la partie gagnante, ou ne sort personne gagnant;
const int size = 3;
int board[size][size]; // 定义3×3 的棋盘
int i,j;
int numOfX;
int numOfO;
int result = -1; // -1：没人赢，1：X赢，0：O赢
// 读入矩阵
for ( i=0; i<size; i++ ){
for( j=0; j<size; j++){
scanf("%d", &board[i][j]); // 读入数组中的每一个元素
}
}
// 检查行
for ( i=0; i<size && result == -1; i++){
numOfO = numOfX =0; // 初始化最开始的数量为0
for( j=0; j<size; j++){
// 判断每一列
if( board[i][j] == 1){
//行号不变，列号从0到size
numOfX ++;
}else{
numOfO ++;
}
}
if( numOfO ==size ){
result =0;
}else if(numOfX == size){
result = 1;
}
}
// 检查列
for ( result == -1 ){
for( j=0; j<size && result == -1; j++){
numOfO = numOfX =0;
for( i=0; i<size; i++){
if( board[i][j] == 1){
numOfX ++;
}else{
numOfO ++;
}
}
}
if( numOfO ==size ){
result =0;
}else if(numOfX == size){
result = 1;
}
}
// 检查对角线。。。。
6. Opérations sur les tableaux
1. Opération de tableau
(1) Références :
- Dans un jeu de données donné, comment savoir si telle ou telle donnée existe ?
[Code]:
- Initialisation intégrée des tableaux :
int a[] = {
2,4,6,7,1,3,5,9,11,13,23,14,32};
int a[13] = {
2};
// 2 0 0 0 0 0 0 0 0 0 0 0 0
- Positionnement lors de l'initialisation de l'intégration :
int a[10] = {
[0] = 2, [2] = 3, 6,
};
// a[0]=2; a[2]=3; a[3]=6; 其它的都为0；
(2) La taille du tableau
sizeofDonner la taille du contenu occupé par tout le tableau, en octets ;
int a[] = {
[1]=2,4,[5]=6}; // 0 2 4 0 0 6
printf("%lu\n",sizeof(a)); // 24
printf("%lu\n",sizeof(a[0])); // 4
- Ainsi, la taille du tableau =
sizeof(a)/sizeof(a[0]); sizeof(a[0])Étant donné la taille d'un seul élément du tableau, la division donne le nombre d'éléments du tableau ;
(3) Affectation du tableau
int a[] = {
[1]=2,4,[5]=6}; // 0 2 4 0 0 6
(False): int b[] = a; // 大错特错！！！！不行！！！！
- Les variables de tableau elles-mêmes ne peuvent pas être affectées ;
- Pour transférer tous les éléments d'un tableau à un autre, il faut utilisertraverser！
int a[] = {
[1]=2,4,[5]=6}; // 0 2 4 0 0 6
for ( i=0; i<length; i++) {
b[i] = a[i];
}
forHabituellement, une boucle est utilisée- erreurs courantes- éviter:
- ① La condition de fin de boucle est <= longueur du tableau ;×××
- ② Après avoir quitté la boucle, continuez à utiliser la valeur de i comme indice des éléments du tableau !×××
注意：Lorsqu'un tableau est utilisé comme paramètre d'une fonction, il est souvent nécessaire d'utiliser un autre paramètre pour passer la taille du tableau !- Car lorsqu'un tableau est utilisé comme paramètre d'une fonction : ① la taille du tableau ne peut pas être donnée dans [ ] ; ② sizeof ne peut plus être utilisé pour calculer le nombre d'éléments du tableau !
2. Rechercher
- Trouver la position d'un certain nombre dans un tableau (ou confirmer s'il existe) ;
- méthode de base :traverser
(1) Recherche linéaire - exemple ① :
#include<stdio.h>
int search(int key, int a[], int len) // len 来表示数组有多大
{
int ret = -1;
for ( int i=0; i<len; i++)
{
if (key == a[i] )
{
ret = i;
break;
}
}
return ret;
}
int main()
{
int a[] = {
1,3,4,5,12,14,23,6,9,45};
int r = search(12, a, sizeof(a)/sizeof(a[0]));
printf("%d\n", r);
return 0;
}
(2) Recherche linéaire - exemple ② :
#include<stdio.h>
int amount[] = {
1,5,10,25,50};
char *name[] = {
"penny","nickel","dime","quarter","half-dollar"};
int search(int key, int a[], int len) // len 来表示数组有多大
{
int ret = -1;
for ( int i=0; i<len; i++)
{
if (key == a[i] )
{
ret = i;
break;
}
}
return ret;
}
int main()
{
int k = 25;
int r = search(k, amount, sizeof(amount)/sizeof(amount[0]));
if ( r > -1)
{
printf("%s\n",name[r]);
}
return 0;
}
Amélioration : rapprocher la dénomination et le nom
#include<stdio.h>
int amount[] = {
1,5,10,25,50};
char *name[] = {
"penny","nickel","dime","quarter","half-dollar"};
struct {
int amount;
char *name;
} coins[] = {
{
1,"penny"},
{
5,"nickel"},
{
10,"dime"},
{
25,"quarter"},
{
50,"half-dollar"}
};
int search(int key, int a[], int len) // len 来表示数组有多大
{
int ret = -1;
for ( int i=0; i<len; i++)
{
if (key == a[i] )
{
ret = i;
break;
}
}
return ret;
}
int main()
{
int k = 10;
// int r = search(k, amount, sizeof(amount)/sizeof(amount[0]));
for ( int i=0; i<sizeof(coins)/sizeof(coins[0]); i++ )
{
if ( k == coins[i].amount ){
printf("%s\n", coins[i].name);
break;
}
}
return 0;
}
(3) Recherche binaire
- Prémisse : faites le tri !
[idées] :
【programme】:
#include<stdio.h>
int search(int key, int a[], int len) // len 来表示数组有多大
{
int ret = -1;
int left = 0;
int right = len-1;
while ( left < right )
{
int mid = (left+right)/2;
if( a[mid] == k )
{
ret = mid;
break;
} else if ( a[mid] > k)
{
right = mid-1;
} else{
left = mid+1;
}
}
return ret;
}
int main()
{
return 0;
}
3. Tri préliminaire - tri sélectif
- Étant donné un tableau non ordonné, comment l'organiser dans l'ordre ?
[idées] :
- trouver le plus grand nombre
- Le plus grand nombre est échangé avec le dernier chiffre, c'est-à-dire
swap a[maxid],a[len-1]; - Trouvez ensuite le plus grand des restants
- faire de même
- ……
- jusqu'à ce qu'il reste les deux derniers chiffres
[Code]:
#include<stdio.h>
int max ( int a[], int len)
{
int maxid = 0;
for (int i=1; i<len ; i++ )
{
if( a[i]> a[maxid] )
{
maxid = i;
}
}
return maxid;
}
int main()
{
int a[] = {
2,45,6,12,87,34,90,24,23,11,65};
int len = sizeof(a)/sizeof(a[0]);
for ( int i=len-1; i>0 ; i-- )
{
int maxid = max(a, i+1);
// swap a[maxid],a[len-1]
int t = a[maxid];
a[maxid] = a[i];
a[i] = t;
}
for (int i=0; i<len; i++)
{
printf("%d ",a[i]);
}
return 0;
}
7. Pointeurs et chaînes
1. Pointeur
(1) Prenez l'opération d'adresse : l'opérateur & obtient l'adresse de la variable
①sizeof
- est un opérateur qui donne le nombre d'octets qu'un type ou une variable occupe en mémoire
#include<stdio.h>
int main()
{
int a;
a = 6;
printf("sizeof(int) = %ld\n", sizeof(int)); // sizeof(int) = 4；int在内存中占4个字节，也就是32个bit
printf("sizeof(a) = %ld\n", sizeof(a)); // sizeof(a) = 4
printf("sizeof(double) = %ld\n", sizeof(double)); // sizeof(double) = 8
return 0;
}
Opérateur ②&
scanf("%d",&i);intérieur&
(2) Pointeur : une variable de pointeur est une variable qui enregistre une adresse
① Pointeur - est la variable qui contient l'adresse
int i;
int* p = &i; // 表示p是一个指针，它指向的是一个 int，把i的地址交给了指针p
int* p,q; // 表示p是一个指针；q是一个普通的 int类型的变量
int *p,q; // 表示p是一个指针；q是一个普通的 int类型的变量
//【无论 * 是靠近 int 还是 p，都是一样的！！】
[Que * soit proche de int ou p, c'est pareil ! ! 】
② variable de pointeur
- La valeur de la variable est l'adresse de la mémoire
- La valeur d'une variable ordinaire est la valeur réelle ;
- La valeur de la variable de pointeur est l'adresse de la variable avec la valeur réelle ;
③ pointeur comme paramètre
void f(int *p);La fonction f attend un pointeur vers un int- Lorsqu'il est appelé, il récupère la valeur d'une variableadresse：
int i=0;f(&i); - Dans la fonction, vous pouvez accéder au i externe via ce pointeur
#include<stdio.h>
void f(int *p);
void g(int k);
int main(void)
{
int i=6;
printf("&i=%p\n", &i);
f(&i);
g(i);
return 0;
}
void f(int *p)
{
printf(" p=%p\n", p);
}
void g(int k)
{
printf("k=%d\n", k); // k = 6
}
④ Accéder à la variable à cette adresse*
- * est un opérateur unaire permettant d'accéder à la variable à l'adresse représentée par la valeur du pointeur
- Il peut s'agir d'une rvalue ou d'une lvalue, c'est-à-dire que * peut être placé à droite du numéro d'affectation pour lire sa valeur, ou il peut être placé à gauche du numéro d'affectation pour écrire sa valeur.
#include<stdio.h>
void f(int *p);
void g(int k);
int main(void)
{
int i=6;
printf("&i=%p\n", &i);
f(&i);
g(i);
return 0;
}
void f(int *p)
{
printf(" p=%p\n", p);
printf("*p=%d\n", *p); // 把 *p 看做一个整体，是int —— *p = 6；
*p = 26; // 此时，k = 26 —— 说明在经历了f函数的调用之后，i的值被改了
}
void g(int k)
{
printf("k=%d\n", k);
}
(3) Pointeurs et tableaux : pourquoi sizeof est-il incorrect une fois le tableau passé à la fonction ?
- Le tableau dans la liste des paramètres de la fonction est en faitaiguille!
void minmax( int a[], int len, int *min, int *max)
// 上面的 int a[] ———— 指针！
// 也可以写成 int *a;
sizeof(a) == sizeof(int*);- Mais vous pouvez utiliser des opérateurs de tableau
[]pour effectuer des opérations - Les quatre prototypes de fonction suivants apparaissent dans la liste des paramètres et sont équivalents :
int sum(int *ar, int n);
int sum(int *, int);
int sum(int ar[], int n);
int sum(int [], int);
① Les variables de tableau sont des pointeurs spéciaux
- Les variables de tableau elles-mêmes expriment des adresses, donc :
- int a[10];int *p=a; // pas besoin d'utiliser & pour obtenir l'adresse
- Mais l'unité du tableau exprime une variable, vous devez utiliser & pour obtenir l'adresse
- un == &a[0];
[]Les opérateurs peuvent être effectués sur des tableaux ainsi que sur des pointeurs :
- p[0] <==> un[0]
*Les opérateurs peuvent être effectués sur des pointeurs ainsi que sur des tableaux :
*a = 25;
- Les variables de tableau sont des pointeurs const, elles ne peuvent donc pas être affectées
int b[]; // 可以看做是 int * const b;
2. Type de caractère
(1) Type de caractère
- char est un entier et un type spécial : caractère.
Ceci est dû au fait:
- Caractères littéraux dénotés par des guillemets simples : 'a', '1'
"est aussi un personnage;- Utilisez %c dans printf et scanf pour entrer et sortir des caractères
① Saisie et sortie de caractères :
#include<stdio.h>
int main()
{
char c;
char d;
c = 1;
d = '1';
if ( c==d ){
// 不相等
printf("相等\n");
} else{
printf("不相等\n");
}
printf("c=%d\n", c); // c=1
printf("d=%d\n", d); // d=49
return 0;
}
- Comment saisir le caractère '1' dans le caractère c ?
scanf("%c", &c); -->1
scanf("%d", &i); c=i; -->49
- Le code ASCII de '1' est 49, donc quand c==49, il représente '1';
#include<stdio.h>
int main()
{
char c;
//scanf("%c",&c); // 输入： 1
//printf("c=%d\n", c); // c=49
//printf("c='%c'\n", c); // c='1'
int i;
scanf("%d",&i); // 输入： 1 or [49]
c = i;
printf("c=%d\n", c); // c=1 or [49]
printf("c='%c'\n", c); // c=' ' or ['1']
return 0;
}
② Entrée mixte :
- Quelle est la différence?
scanf("%d %c",&i,&c);
scanf("%d%c",&i,&c);
- scanf("%d %c",&i,&c); :
#include<stdio.h>
int main()
{
char c;
int i;
scanf("%d %c",&i,&c);
printf("i=%d, c=%d, c='%c'\n", i, c, c);
return 0;
}
- scanf("%d%c",&i,&c); :
#include<stdio.h>
int main()
{
char c;
int i;
scanf("%d%c",&i,&c);
printf("i=%d, c=%d, c='%c'\n", i, c, c);
return 0;
}
- C'est-à-dire qu'après %d, s'il n'y a pas d'espace, cela signifie que l'entier n'est lu que jusqu'à la fin de l'entier, et ce dernier est donné au suivant ;
- S'il y a un espace, après que l'entier a lu l'espace, tous les espaces après doivent être lus !
- Par conséquent, cela fait une différence qu'il y ait un espace ou non!
③ Conversion de cas
a+'a'-'A'Vous pouvez convertir des lettres majuscules en lettres minuscules ;a+'A'-'a'Les lettres minuscules deviennent majuscules !
(2) caractères d'échappement
- Utilisé pour exprimer des caractères de contrôle ou des caractères spéciaux qui ne peuvent pas être imprimés. Il
“/”commence par une barre oblique inverse suivie d'un autre caractère. Ces deux caractères correspondent pour former un caractère ;
printf("请分别输入身高的英尺和英寸，"
"如输入\"5 7\"表示5英尺7英寸：");
| personnage | importance |
|---|---|
\b |
Reculer d'une case |
\t |
à l'emplacement de table suivant |
\n |
nouvelle ligne |
\r |
retour chariot |
\" |
Double citation |
\' |
apostrophe |
\\ |
la barre oblique inverse elle-même |
①\b
- Remontez d'une grille, laissez la sortie suivante revenir à cette position
- Mais s'il ne produit rien, rien ne change
- Si vous sortez quelque chose, écrasez simplement la chose tout à l'heure
- Habituellement, c'est pour revenir à Ang, mais pas pour supprimer ;
- Mais il est indéniable qu'il peut y avoir un logiciel terminal, qui sera supprimé lors de l'exécution
②\t
- position fixe pour chaque rangée
- Un \t fait démarrer la sortie au prochain taquet de tabulation
- Utilisez \t pour aligner les lignes supérieure et inférieure
3. Chaîne
(1) chaîne
- Les chaînes en langage C sonttableau de caractèresexistant dans la forme ;
- Les opérateurs ne peuvent pas être utilisés pour opérer sur des chaînes
- Les chaînes peuvent être itérées dans un tableau
- La seule exception est que les littéraux de chaîne peuvent être utilisés pour initialiser des tableaux de caractères
- et la bibliothèque standard fournit une série de fonctions de chaîne
① tableau de caractères
char word[] = {
'H','e','l','l','o','!'};
// 但 这不是C语言的字符串，因为不能用字符串的方式做计算！！
char word[] = {
'H','e','l','l','o','!','\0'}; // 是字符串！
② Chaîne
- Une chaîne de caractères terminée par 0 (entier 0)
- 0 ou '\0' sont identiques, mais différents de '0'
- 0 marque la fin de la chaîne, mais il ne fait pas partie de la chaîne
- Ne pas inclure ce 0 lors du calcul de la longueur de la chaîne
- chaîne avecdéployerexiste sous la forme detableau ou pointeuraccès au formulaire. Plus sous forme de pointeurs
- Il existe de nombreuses fonctions dans string.h pour traiter les chaînes
③ Variable de chaîne
char *str = "hello";
char word[] = "hello";
char line[10] = "hello"; // 占据6个字节的line空间 —— 因为还有个结尾的0
④ Constante de chaîne
- "Bonjour"
- "hello" sera transformé en un tableau de caractères et placé quelque part, la longueur de ce tableau est de 6, et il y a un 0 à la fin pour indiquer la fin ;
- Deux constantes de chaîne adjacentes seront automatiquement concaténées ;