当前位置：网站首页>C fonctions linguistiques

#include<stdio.h>
#include<string.h>
int main ()
{
    char arr1[]="abcdef";      //a b c d e f
    char arr2[20]={0};
    strpy(arr1,arr2};
    printf("%s\n",arr2);
    return 0;
}

memset（Paramètres de mémoire）
void * memset ( void * ptr, int value, size_t num );

#include<stdio.h>
#include<string.h>
int main()
{
  char  arr[]="Hello World";
  memset(arr+6,'x',3);

//. La mémoire est définie en octets , Et le contenu de chaque octet est le même value, À partir du sixième octet , Les trois derniers sont x


 printf("%s\n",arr);
return 0;
}

2..Fonction personnalisée

Les fonctions personnalisées, comme les fonctions de bibliothèque, sont définies par Nom de la fonction, Type de valeur de retour et composition des paramètres de fonction .

Type retourné Nom de la fonction（Paramètres de la fonction）
{
Élément de déclaration;
}

Par exemple:： Écrivez une fonction qui compare les deux tailles .

#include<stdio.h>
int get_max(int x,int y)           //int  Est le type de retour   get_maxEst le nom de la fonction   int x,int yC'est le paramètre
{
   
   return (x>y) ? (x) : (y);       //Élément de déclaration
}
int main ()
{
   int a=10;
   int b=20;
   int max = get_max(a,b);
 printf("%d\n",max);
return 0;
}

Fonction d'échange d'une variable entière ：

// Mauvaise forme 
#include <stdio.h>
//Mise en œuvre en fonction,Mais la tâche ne peut pas être accomplie
void Swap1(int x, int y) {
 int tmp = 0;
 tmp = x;
 x = y;
 y = tmp; }
//Forme correcte
#include<stdio.h>
void Swap2(int *px, int *py)   //Ginseng
{
 int tmp = 0;
 tmp = *px;
 *px = *py;
 *py = tmp;
 }
int main()
{
 int a= 4;
 int b = 8;
 Swap1(a, b);      //Appel de valeur
 printf("Avant l'échange：a = %d b = %d\n", a, b);
//Arguments réels
 Swap2(&a, &b);    //Appel d'adresse
 printf("Après l'échange:a = %d  b = %d\n", a, b);
 return 0;
 }

Quand un argument est passé à un paramètre formel,Un paramètre est une copie temporaire d'un argument,Les modifications apportées aux paramètres n'affectent pas les arguments.

swap1:Pendant l'appel,On vaaEtb La valeur de est passée à x,y. Ensuite, dans la fonction x,yEffectuer un échange numérique, Mais ça n'a pas changé a,b.Parce quex,yC'est un paramètre, Ce qui est détruit quand il n'y en a plus , Uniquement pour le stockage temporaire des valeurs originales , Donc ça ne peut pas changer du tout a,bValeur de.

swap2:Pendant l'appel,C'est l'adresse.,Passez l'adresse au pointeur*px,*py.*pxC'est - à - dire:aAdresse,*pyC'est - à - dire:bAdresse, Variable stockée dans l'adresse , Il est alors possible de localiser la variable originale en fonction du pointeur .

swap1 Et Swap2 Arguments en fonction x,y,px,py Tous.Paramètres de forme.InmainPasser à la fonction swap1 De a,b Et la biographieVoilà. Swap2 Fonction &a , &b - Oui.Paramètres réels.Swap1 La fonction est appelée, x , y Avoir son propre espace,Et a exactement le même contenu que l'argument. Donc nous pouvons simplement penser：Après l'Instanciation du paramètre, il s'agit en fait d'une copie temporaire du paramètre.

Arguments de la fonction：

Paramètres réels transmis à la fonction,Appelé argument.
Les arguments peuvent être：Constante、Variables、Expression、Fonctions, etc.
Quel que soit le type de quantité de l'argument,Lors d'un appel de fonction,Ils doivent tous avoir une valeur certaine,Pour transmettre ces valeurs aux paramètres formels.

Paramètres formels de la fonction：

Un paramètre formel est une variable entre parenthèses après le nom de la fonction,Parce que les arguments formels ne sont instantanés que lorsque la fonction est appelée（Allouer des unités de mémoire）,Donc ça s'appelle un paramètre formel.Le paramètre de forme est automatiquement détruit lorsque l'appel de fonction est terminé.Par conséquent, les arguments formels ne sont valables que dans les fonctions.

Appel de valeur:

Les arguments formels et réels de la fonction occupent différents blocs de mémoire respectivement,Les modifications apportées aux paramètres n'affectent pas les arguments.

Appel d'adresse：

Un appel d'adresse est un moyen d'appeler une fonction en passant l'adresse mémoire d'une variable créée à l'extérieur de la fonction à un paramètre de fonction.
Cette façon de passer les paramètres permet à la fonction d'établir un lien réel avec les variables à l'extérieur de la fonction,C'est - à - dire que la fonction peut fonctionner directement à l'intérieur
Comme variable en dehors de la fonction.

Appels imbriqués de fonctions：

Les fonctions peuvent être imbriquées,Mais les définitions ne peuvent pas être imbriquées( .Vous ne pouvez pas avoir une définition d'une autre fonction à l'intérieur d'une fonction )

#include <stdio.h>
void new_line()
{
 printf("hehe\n");
}
void three_line()
{
    int i = 0;
 for(i=0; i<3; i++)
   {
        new_line();
   }
}
int main()
{
 three_line();
 return 0;
}

mainAppelé dans la fonctionthree_lineFonctions,three_line La fonction est appelée une fois chaque fois qu'une boucle est exécutée new_lineFonctions,new_line La fonction est d'imprimer hehe. Donc le résultat final de ce programme est d'imprimer 3- Oui.hehe. C'est un appel imbriqué .

Accès en chaîne：

Prendre la valeur de retour d'une fonction comme paramètre d'une autre fonction prendre la valeur de retour d'une fonction comme paramètre d'une autre fonction .

#include <stdio.h>
#include <string.h>
int main()
{
    char arr[20] = "hello";
 int ret = strlen(strcat(arr));
 printf("%d\n", ret);
 return 0; 
}
//#include <stdio.h>
//#include <string.h>
//int main()
//{
//    char arr[20] = "hello";
// printf("%d\n", strlen(strcat(arr)));
// return 0; 
//}

#include <stdio.h>
int main()
{
    printf("%d", printf("%d", printf("%d", 43)));
    return 0;
}

Et ce résultat final ？

D'abord.printf À l'intérieur, puis à l'extérieur .

En bas.printfValeur de retour de：（Peut passer https://cplusplus.com/ Requête）

Renvoie le nombre de caractères imprimés .soImprimer d'abord43 ,Les résultats sont les suivants:

printf("%d", printf("%d",43));

Parce que'43'C'est deux caractères,Alors... printf("%d",43) Le résultat de2.Après：

printf("%d",2);

'2'Est un caractère,Alors imprimez comme1.

Le résultat final est4321

Déclaration de la fonction：

Définition：
1.Dites au compilateur quel est le nom d'une fonction,Quels sont les paramètres?,Quel est le type de retour.Mais existe - t - il?,Fonctions Je ne peux pas décider..
2. La Déclaration d'une fonction apparaît généralement avant l'utilisation de la fonction.À satisfaireDéclaration avant utilisation.
3. Les déclarations de fonctions sont généralement placées dans le fichier d'en - tête

Définition de la fonction：

Définition：La définition d'une fonction fait référence à la mise en oeuvre concrète d'une fonction,Réalisation fonctionnelle de la fonction d'attente.

#include<stdio.h>
//Déclaration de la fonction
int add(int x,int y);

int main()
{
  int a=10;
  int b=20;
  int sum=add(a,b);
  printf("%d\n",sum);
}
//Définition de la fonction
int add(int x,int y)
{
  return (x+y);
}

Récursion

La technique de programmation que le programme appelle lui - même est appelée récursion（ recursion）.
La récursion en tant qu'algorithme est largement utilisée dans les langages de programmation.
Une procédure ou une fonction a une définition ou une description, directe ou indirecte Une façon d'appeler soi - même,Il convertit souvent les couches d'un grand problème complexe en un problème plus petit qui est similaire au problème original pour trouver.
La stratégie récursive peut décrire les calculs répétés nécessaires pour résoudre le problème avec un petit nombre de programmes,Réduit considérablement la quantité de Code du programme.
Conditions：
1.Il y a des restrictions,Quand cette restriction sera remplie,La récursion ne se poursuit plus.
2.De plus en plus près de cette limite après chaque appel récursif

Exemple： Accepter une valeur entière（Sans symbole）,Imprimez chacun de ses bits dans l'ordre.

#include <stdio.h>
void print(int n)
{
 if(n>9)
 {
 print(n/10);
 }
 printf("%d ", n%10);
}
int main()
{
 int num = 1234;
 print(num);
 return 0;
}

printLa fonction peut mettrenum Chacun de ces chiffres est imprimé dans l'ordre .

Tout d'abord,numAssigné comme1234,EntréeprintEn fonction.Passe./10Après123

Encore une foisprint Après la fonction est 12

Et voilà.print Après la fonction est 1

Parce que1%10Pour1,Imprimer1, Puis retournez à la fonction précédente ,printPour12En fonction de,12%10Pour2,Imprimer2 , Imprimez ici 3Et4

Processus：print（1234）---print（123）4---print（12）3 4---print（1） 2 3 4---print 1 2 3 4

Exemple：La création de variables temporaires n'est pas autorisée, Simulation récursive strlenTrouver la longueur de la chaîne.

#include <stdio.h>
int my_strlen(char* str)
{
	if (*str != '\0')
		return 1 + my_strlen(str+1);
}
int main()
{
	char arr [] = "abcdef";
	int len=my_strlen(arr);
	printf("%d\n",len);
	return 0;
}

Trouver la longueur de la chaîne,Rencontre\0Arrête.,\0 Il y avait plusieurs caractères qui étaient la longueur de la chaîne .

Ça vient de commencer. str- Oui.aPas égal à\0,str+1C'estb, Continuez jusqu'à ce que \0 ,Code de résiliation.

Itération：

Les itérations sont des activités qui répètent le processus de rétroaction,Le but est généralement d'approcher l'objectif ou le résultat désiré.Chaque répétition du processus est appelée une“Itération”,Et le résultat de chaque itération sera la valeur initiale de la prochaine itération.Répétez une série d'étapes de calcul,Le processus de détermination des quantités suivantes à partir des quantités précédentes.Chaque résultat de ce processus,Sont obtenus en appliquant les mêmes étapes de calcul aux résultats obtenus précédemment.

Par exemplenFactoriel de：( A condition que le débordement de pile ne soit pas pris en compte ）

#include<stdio.h>
int fac(int n)
{
	if (n < 2)
		return 1;
	else
		return n * fac(n - 1);
 }
int main()
{
	int n = 0;
	scanf_s("%d\n", &n);
	int ret = fac(n);
	printf("%d\n", ret);
	return 0;
}

Exemple2：S'il vous plaît.nSérie Fibonacci（Débordement de pile non pris en compte）

#include <stdio.h>
int count = 0;
int fuc(int n)
{
    if (n == 3)
        count++;//Enregistrementx==3Combien de fois
    if (n <= 2)
        return 1;
    else
        return fuc(n - 2) + fuc(n - 1);
}
int main()
{
    int n;
    printf("Veuillez saisir un nombre");
    scanf("%d",&n);
    printf("Numéro de la série Fibonacci%dLa valeur de l'élément est%d", n, fuc(n));
    printf("Nombre d'appels%d", count);
    return 0;
}

Parce que le débordement de pile n'est pas pris en compte , Après avoir entré une grande valeur , Les calculs sont très gênants , Parce que c'est un cycle continu , Vous pouvez changer la récursion en cas de non - récursion .

La situation après le changement de factoriel ：

#include <stdio.h>
int fac(int n)
{
    int result = 1;
    while (n > 1)
    {
        result *= n;
        n -= 1;
    }
    return result;
}
int main()
{
    int n;
    printf("Veuillez entrern=>");
    scanf("%d",&n);
    printf("%dFactoriel de%d",n,fac(n));   
    return 0;
}

Par exemple:n>1,Prends ça.n La valeur de est multipliée par resultÀ l'intérieur,Et puisnDégressif, Continuez à multiplier. ,Boucle - le.,Jusqu'àn<=1C'est,Renvoie les résultats.Si nous entrons5,result=1*5=5→result=5*4=20→20*3=60→60*2=120

Après la modification des séries Fibonacci ：

#include <stdio.h>
int fuc(int n)

{
    int a = 1,b = 1, c = 1;
    int i;
    while (n>2)
    {
            c = a + b;
            a = b;
            b = c;
            n--;
    }
        return c;
    }
int main()
{
    int n;
    printf("Veuillez saisir un nombre");
    scanf("%d", &n);
    printf("Numéro de la série Fibonacci%dLa valeur de l'élément est%ld", n, fuc(n));
    return 0;
}

Série Fibonacci：
1 1 2 3 5 8 13 21 34 55
a b c
Ça vient de commencer.a=1,b=1,cCompte.,EncorebValeur attribuée àa,cValeur attribuée àb,Dans le calculc Compte à tour de rôle , Peut produire des résultats rapides .

原网站

版权声明
本文为[Réveillez - vous à la tombée de la nuit.]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/185/202207040954584292.html