Une compréhension préliminaire du langage C : fonctions, tableaux, opérateurs

Qu'est-ce qu'une fonction ? A quoi servent les fonctions ?
Premièrement, une fonction est un module du langage C, qui est construit pièce par pièce et a une forte indépendance et peut s'appeler. En d'autres termes, en langage C, une fonction peut appeler n fonctions, c'est-à-dire une grande fonction appelle une petite fonction, et une petite fonction appelle à son tour la "petite" fonction. Il s'agit d'une programmation structurée, c'est pourquoi les langages orientés processus sont également appelés langages structurés. Deuxièmement, une fonction est une collection d’une série d’instructions C pouvant accomplir une fonction spécifique. .Appelez cette fonction directement lorsque vous en avez besoin, sans empiler le code à chaque fois. Lorsque vous devez modifier cette fonction, il vous suffit de modifier et de maintenir cette seule fonction.

Par exemple : l'application de la fonction principale et de la sous-fonction dans la figure ci-dessous : la fonction somme, lorsque la fonction principale est exécutée, lorsque le programme s'exécute sur "int sum = Add (n1, n2)", l'externe "Add sous-fonction" sera appelée pour réaliser que les deux nombres s'additionnent.

2. Commencez par connaître les tableaux

1. La forme et la définition d'un tableau

"une collection d'éléments du même type"

2. Comment accéder à la baie ?

Par conséquent, lorsque le programme peut accéder au tableau, c'est dans l' ordre des indices (0-9)

3. Opérateur

opérateur de comptage

1. / (division)

Dans une opération de division, si les opérandes de part et d'autre du signe de division sont des entiers, le résultat est la partie du quotient

Opérande : Désigne le dividende et le diviseur

Par exemple : a/ba et b sont tous deux des entiers, si a<b, le résultat est 0

(Le résultat de la division d'un nombre décimal par un grand nombre est 0)

Dans deux opérations entières, le langage C suit la règle (arrondi à 0)

Ce qu'on appelle l'arrondi vers 0 signifie arrondir vers 0 sur l'axe des nombres.

Ex : 10/8=1,25 opération mathématique

10/8 =1 langage C

Parce que 1,25>0 ne prend pas l'entier 2 lors de l'arrondi, mais prend 1 car 1 est plus proche de 0 que de 2

Dans une opération de division, tant qu'un opérande est un nombre à virgule flottante, il s'agit d'une opération de division d'un nombre à virgule flottante

L'opération dite de division des nombres à virgule flottante est que le résultat final est un nombre à virgule flottante


#include <stdio.h> 
int main()
{
    printf("%d\n",20/10);//结果就是一个是整数 
    //小数除大数
    printf("%d\n",2/19);//结果为0 
    printf("%lf\n",20.0/10);//结果是一个浮点数
    printf("lf\n",20.0/10.0);//结果是一个浮点数    
    return 0;
}

2, % (module, reste)

Le résultat obtenu dans l'opération modulo est le reste restant après la division de deux nombres

Les opérateurs des deux côtés de l'opération de reste ne peuvent être que des entiers

En arithmétique modulo, a%b donne a lorsque la valeur de a est inférieure à b

(Le résultat du nombre décimal modulo grand est la décimale elle-même)

#include <stdio.h>
int main()
{
	//两数进行模运算
	printf("%d\n", 3 % 2); //1
 
	//小数 模 大数 得到的是小数本身
	printf("%d\n", 4 % 5); //3
	return 0;
}

opérateur de quart

1. << opérateur de décalage vers la gauche

Lors du décalage de bits binaires, ce qui est décalé est le complément à deux

Règles de décalage :

Comment se déplace l'opérateur de décalage vers la gauche : rejetez à gauche et ajoutez 0 à droite

Les opérateurs de décalage ne peuvent pas décaler les bits négatifs

#include <stdio.h>
int main()
{
	//左移操作符 <<
	int a = 10;
//a 的原码：00000000 00000000 00000000 00001010
//正数的原码 反码、补码 相同
	int b = a << 1;
//将a左移一位：00000000 00000000 00000000 00010100
// 左移一位之后还是一个正数，原、反、补 相同
// b=20
	printf("%d\n", b);
}

2. >> Opérateur de décalage vers la droite

Ce qui est décalé est le bit binaire, et ce qui est décalé est le complément du bit binaire

Règles de décalage :

1. Décalage arithmétique à droite : le côté droit supprime le bit de signe complémentaire gauche (utilisé par la plupart des compilateurs)

2. Décalage logique vers la droite : le côté droit est ignoré et le côté gauche est rempli de 0

#include <stdio.h>
int main()
{
//0 表示正数，1表示负数
	int a = -10;
//a原码 : 10000000 00000000 00000000 00001010
// 反码： 11111111 11111111 11111111 11110101
// 补码： 11111111 11111111 11111111 11110110
//将补码算术右移一位
	int b = a >> 1;
//补码：11111111 11111111 11111111 11111011
//	    10000000 00000000 00000000 00000100
//原码：10000000 00000000 00000000 00000101
// b=-（1+4）=-5
	printf("%d\n", b);
	return 0;
}

opérateur logique

1. && et


#include <stdio.h>
int main()
{
	//&:有0为假 有为1为真
	int a = 7;
	int b = 20;
	int c = a && b;
	printf("%d\n", c);//最后结果为0

	return 0;
}

2, || ou

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = a || b;
	printf("%d\n", c);

	return 0;//结果为1
}

3. ! NON logique

! opérateur inverse logique

Que le vrai devienne faux, le faux devienne vrai

opérateur unaire

Un opérande avec un seul opérande

1.! : inversion logique

2.- : Opérateur de valeur négative

3.+ : Valeur positive

4.& : Prendre l'adresse

5. taille de l'opérateur

L'opérateur sizeof est un opérateur, pour le distinguer de la fonction

sizeof est principalement utilisé pour calculer la taille du type de données en mémoire (en octets)

Lors du calcul de la taille de la variable, les parenthèses de sizeof peuvent être omises

6.- - Décrémentation

Pre--- : d'abord --, puis utilisez (décrémentez d'abord la variable de 1, puis utilisez-la)

Post-- : utilisez d'abord, puis-- (utilisez d'abord, puis laissez la variable décrémenter de 1)

#include <stdio.h>
int main()
{
	//前置--
	int a = 10;
	int b = --a;
	//此代码执行了两部操作
	// 第一步：a=a-1；
	// 第二步：b=a;
	printf("%d\n", b);//b的值为9
 
	//后置--
	int c = 20;
	int d = c--;
	//此代码也执行了两步操作
	// 第一步：d=c;
	// 第二步：c=c-1;
	printf("%d\n", d);//d的值为20
	return 0;
}

7.++ Incrémentation automatique

Pré-++ : utilisez d'abord ++ (incrémentez d'abord la variable de 1, puis utilisez-la)

Post ++ : utilisez d'abord post ++ (utilisez d'abord, puis laissez la variable augmenter de 1)

#include <stdio.h>
int main()
{
	//前置++
	int a = 10;
	int b = ++a;
	//分为两步
	// a=a+1;
	// b=a;
	// 先让a自增1 再使用a 把a的值赋给b
	printf("%d\n", b);//b的值为11
 
	//后置++
	int c = 20;
	int d = c++;
	//分为两步
	// d=c;
	// c=c+1;
	//先使用c 把c的值赋给d 再让c自增1
	printf("%d\n", d);//d的值为20
	return 0;
}

8.* opérateur de déréférencement

L'opérateur de déréférencement, également connu sous le nom d'opérateur d'indirection, fonctionne sur les pointeurs

Fonction : déréférencer la variable de pointeur consiste à obtenir le contenu pointé par la variable de pointeur

9. (type) conversion de type obligatoire

La conversion de type obligatoire est la conversion d'un type de données en un autre type de données

Remarque : La troncature se produit lors de la conversion d'un type de grande taille en un type de petite taille.

Lorsque le type float ou double est forcé en type int : la troncature se produit et la partie entière est prise

Lorsque le type char est forcé au type int : obtenez la valeur du code ASCII correspondant
#include <malloc.h>
#include <stdio.h>
 
int main()
{
	// float 转 int 截断取整数部分 
	float a = 3.14f;
	int b = (int)a;
	printf("%d\n", b);// b为3
 
	// double 转 int 截断取整数部分 
	double d = 4.225;
	int e = (int)d;
	printf("%d\n", e);// e为4
 
	// char 转 int  取到ASCLL值
	char c = 'A';
	int f = (int)c;
	printf("%d\n", f);// f 为 65
 
	//动态内存开辟
	// 将在堆区上开辟的空间强制转化为int* 类型 赋给 指针p 
	int* p = (int*)malloc(sizeof(int)* 13);
 
	//时间戳产生随机数
	//将time 函数的返回值强制转化成 unsinged int (无符号整型） 
	// srand 函数的参数是一个无符号整型所以强制类型转换
	srand((unsigned int)time(NULL));
	int x = rand();//产生一个 0 - 32767 的随机数
	printf("%d\n", x);//每次打印出现的结果都不一样
 
	return 0;
}

opérateur relationnel

>、>=、<、<=、==、!=

Tout comme les jugements en mathématiques,

Mais il y en a un de plus != (pas égal) : pour juger si deux nombres ne sont pas égaux

opérateur conditionnel

expression1 ?expression2 : expression3

expression 1 ? Expression 2 : expression 3 ;

Opérateur conditionnel, également appelé opérateur ternaire, car il comporte trois opérandes

Exécutez l'expression 2 lorsque l'expression 1 est vraie, sinon exécutez l'expression 3

#include <stdio.h>
 
int main()
{
	//输入两个数打印两个数中的较大值
	int a = 0;
	int b = 0;
	scanf("%d %d", &a, &b);
	
	int max = (a > b ? a : b);
	printf("%d\n", max);
 
	//a > b ? printf("%d\n", a) : printf("%d\n", b);
	return 0;
}

expression virgule

expression1, expression2, ..., expressionn

Les expressions virgules sont plusieurs expressions séparées par des virgules

Les expressions virgules sont exécutées de gauche à droite

Le résultat de l'expression virgule est la dernière expression

#include <stdio.h>
int main()
{
	int a = 10;
	int b = 20;
	int c = 30;
	
	//d的结果就是逗号表达式中最后一个表达式的结果
	//也就是将c的值赋给d
	int d = (a, b, c);
	printf("%d\n", d); // d为30
}