Le voyage de mille miles commence par une seule étape, et la pagode de neuf étages commence à partir de la base du sol. C n'est pas assez solide, alors j'ai recommencé la pratique. Quelques notes auxquelles il faut prêter attention pendant le processus
1. Le code original, le code inverse et le code complément des nombres positifs sont les mêmes !
2. Opération logique
Règle 1 : tant que l'un des opérandes est un type à virgule flottante, l'expression est un type à virgule flottante, l'opérande est un entier et l'expression est également un entier. Par exemple
:
flottant a=0，c=0 ;
un=5/2 ;
printf("%f\n",a);
imprime 2
au lieu de 2,5
Solution L'un des opérandes est remplacé par un type à virgule flottante et l'expression de sortie est un type à virgule flottante.
Règle 2 : Les deux opérandes de l'opérateur % reste doivent être des entiers et le signe du résultat de l'expression est déterminée par le dividende.
Exemple
Règle détaillée 3 : opérateur d'auto-incrémentation et d'auto-décrémentation
a++ ;
lire d'abord puis écrire,
lire d'abord a puis effectuer des opérations arithmétiques
, à savoir :
printf("d%\n",a) ;
a=a+1 ;
++a ;
écrivez d'abord puis lisez
Effectuez d'abord une opération arithmétique sur a puis lisez
:
a=a+1 ;
printf(“d%\n”,a);
Règle 4 Opérateur d'affectation
Règle 5 :
Le résultat de sizeof (expression) est le nombre d'octets occupés par le type de données de l'expression
Règle 6 : Opérations mixtes de différents types de données, l'ordinateur convertira automatiquement en données de haute précision pour assurer la précision de l'opération Type
Par exemple :
char doit être converti en int
float doit être converti en double
3. Algorithme
Règle 1 : Paramètre d'entrée
scanf("%d%d", &a, &b) ;
Règle 2 : Trouver impair et pair nombres
if (a%2! 0)
{}
Règle 3 : instructions couramment utilisées
if (expression) {}
if (expression) {} else (expression) {}
if (expression) {} else if (expression) else (expression) {}
switch(expression)
{ case expression constante 1 : instruction 1 ; break ;
case expression constante 1 : instruction 1 ; break ;
default : instruction
}
Interprétation :
1. Si l'expression if est vraie, exécuter le contenu if.
2. Si l'expression if est vraie, exécuter le contenu if. Si elle est fausse, exécuter le contenu else.
3. Si l'expression if est vraie, exécuter le contenu du if. S'il est faux, l'
expression else if est Si le contenu du else if est vrai, exécuter
le
contenu du else s'il
est faux. Valeur) instruction break (sortie du commutateur) L'expression du commutateur ne peut pas être un type à virgule flottante, il doit s'agir d'une valeur fixe } 4. Règle de tableau unidimensionnel 1 : la longueur du tableau doit être une expression constante entière, qui peut être précompilée dans la formule de définition de la macro, reportez-vous à la définition de la macro dans le tableau Règle 2 : Le tableau non assigné, le contenu est inconnu Exemple : int arr[5]; arr[0]=?;arr[1]=? ... Règle 3 : Affectation partielle, la partie non affectée restante est 0 int arr[5={0};]; arr[0]=0;arr[1]=0... Règle 4 : Utilisez sizeof() pour obtenir la longueur Règle 5 : Obtenir la longueur du tableau (nombre total d'octets/taillede(type)) Exemple : int arr[5]={0} ; printf("longueur : %d\n", sizeof(arr)/sizeof( arr[0]) )
5. Tableau à deux dimensions
Règle 1 : Un tableau à deux dimensions occupe plusieurs espaces mémoire continus, ce qui équivaut à la continuité d'un tableau à une dimension Exemple :
Règle
2 : Nombre total d'octets = sizeof (type de tableau) * nombre de lignes, nombre de colonnes
Règle 3 : Calcul La formule de la position de l'élément dans le tableau
Exemple a[ 1 ][ 2 ] est le 1er du tableau 3+2=5e
6. Tableau à une dimension
7. Tableau bidimensionnel
8.
Détails de la structure 1 :
Exemple
struct student
{ int num ; int c_score} ;float avgint ps_score ; ; la valeur initiale Méthode d'attribution de la valeur initiale 1.struct student Tom={10,90,98,94.5} ; 2 .Tom.num=10 ; Détail 2 : lors de la déclaration du type, définissez la variable Exemple 1 struct student { int num ; int c_score ; int ps_score ; float avg ; } ; //struct student //type name //struct student Tom ; //Tom variable //struct student Tom = {10}; //struct initial value, similar to a array Assignment //Après avoir défini la variable de structure, //Vous pouvez utiliser Tom.num = 10; pour assigner des valeurs aux éléments de la structure Exemple 2
struct student
{ int num; int c_score; int ps_score; float avg; }Tom;//Tom est une variable de structure (les variables sont définies lors de la déclaration, équivalent à struct student Tom;) Exemple 3 struct student { int num; int c_score; int ps_score; float avg; }Tom; Jary;//Tom et Jary sont des variables de structure (les variables sont définies en même temps que declaration, ce qui équivaut à struct student Tom;) Règle 3 : Les variables occupent de l'espace mémoire Règle 4 : Structure est omis Nom, définissez directement la variable de structure struct // étudiant (cette méthode ne peut être définie qu'une seule fois, puis la variable de structure ne peut pas être définie à nouveau) { int num ; int c_score ; int ps_score ; float avg ; }Tom ; Jary ; //Tom, Jary est une variable de structure Règle 5 : Structure array assign struct student
{ int num ; int c_score[2] ; int ps_score ; }Tom ; Jary ; //Tom et Jary sont des variables de structure Affectation : struct student Tom = {10, {20,30,40}, 50} ;// Empêcher la tableau de l'étudiant de structure manquant Jary = {10, 20, 30, 40, 50} ;
8. Typedef donne au type
existant un alias typedef signé char int8 ; // le caractère signé a est équivalent à int8 a ; détail 2 : utilisation de la structure typedef Exemple 1 typedef struct étudiant { int num ; int c_score[2] ; int ps_score ; }STU;//Après l'ajout de typedef, le STU n'est plus ici une variable de structure //mais un alias de la structure struct student STU Tom={10, {20,30,40}, 50}//équivalent à struct student À M
Règle 3
& est le caractère d'adresse//transmettre à l'adresse cible
9. Tableau de structure
Méthode de définition 1
struct étudiant
{ int num; int c_score[]; int ps_score; };//Définition structure struct étudiant classe1[5];
Méthode de définition 2
struct student
{ int num; int c_score[]; int ps_score; }; class1[5]; //class1 est le nom du tableau de structure/indique qu'il existe 6 structures de type struct student
Méthode d'initialisation
struct étudiant classe1[2] = {
{10,{20,30,40},50},{10,{20,30,40},50},{10,{20,30,40},50 }};//Initialiser les valeurs initiales des membres des 3 structures
Utilisation d'un tableau structurel
L'exemple 1
nécessite de trouver le score le plus élevé parmi N étudiants et de sortir les informations sur l'étudiant
typedef struct student
{ int num; int score; }STU; //STU est l'alias de la structure STU class1[n]= { { { 10,90},{20,70},{30,95}} ; int i =0 ; int max=0 ; for(i=1;i<n;i++) { if(class1[i]. score > classe1[max].score) max=i;//filtrer le score le plus élevé } print("L'étudiant avec le score le plus élevé :\n") print("Numéro de série : %d\n", class1[max].num ); print("numéro de série : %d\n", classe1[max].score);
heure:2021/11/24
9. Portée et variables
Règle 1 :
Portée du fichier (variable globale) : Couvre le fichier du début à la fin
Portée de la fonction (variable locale) : Les paramètres et le corps de la fonction appartiennent à la portée de la fonction, la valeur de retour Le nom de la fonction appartient à la portée du fichier Règle
2 :
Conforme au bloc d'instructions : {}, qui appartient à la portée du bloc d'instructions
Règle 3 :
1. Des portées différentes ne seront pas en conflit
2. La même portée est proche l'une de l'autre
Règle 4 :
portée étendue externe : les identifiants de portée de fichier peuvent étendre leur portée à travers elle
10.
Règles internes de stockage 1 :
Variables de pile : modification automatique (par défaut omis) -> 99 % des variables locales
statiques modifiées ouvriront directement des blocs de mémoire au moment de la compilation -> 1 % des variables locales
détruisent des blocs de mémoire : exécution de la fonction Après la complétion, la mémoire sera retournée.
Règle 2 ;
déclaration de variable -> ouvrir un bloc mémoire
au-delà de la portée de la portée -> en fait, l'espace mémoire de la variable locale est détruit après l'exécution de la portée
Règle 3 :
Globale variables (variables statiques) : utiliser static pour déclarer
la mémoire Temps de développement : temps de compilation
Temps de destruction de la mémoire : à la fin de la fonction principale
Règle 4
les paramètres formels ne peuvent pas être déclarés statiques, ils ne peuvent être utilisés que comme variables locales modifiées par auto
Règle 5
Variables ne reçoivent pas une valeur par défaut de 0
Règle 6
Les identifiants globaux (macros/variables/fonctions) utilisent la modification statique, n'indiquent pas la zone globale, mais indiquent que l'identifiant ne peut être étendu et utilisé que dans ce fichier
Extension : Règles de dénomination de l'identifiant :
nom de la macro -> tout en majuscules,
nom de la variable -> un seul mot est en minuscule, le premier mot de plusieurs mots est en minuscule et la première lettre de chaque mot suivant est en majuscule
Nom de la fonction -> un seul mot est en majuscule, plusieurs mots Mettre en majuscule la première lettre de chaque mot
11.
Règles du pointeur 1
Le pointeur est l'adresse
et le symbole d'adresse (printf("%p\n",&a);->obtenir la position de l'adresse de a en mémoire),
où l'adresse de a est une constante et l'adresse de une variable est une constante et ne peut pas être modifiée et transformée
12. Pointeur variable
Règle 1
- *a // * opérateur pointeur
heure : 2021/11/25
Référence de
https://www.bilibili.com/video/BV1iz4y1S7NK?p=11