Chaque programme C a au moins une fonction, la fonction principale main(), Si la tâche du programme est relativement simple, tout le code est écrit dans la fonction main(). Cependant, dans le développement réel, la tâche du programme est souvent plus complexe si tout le code est écrit dans la fonction main(). , la fonction main() sera très volumineuse et volumineuse, avec une structure complexe et un code répété.
Nous pouvons diviser le code en différentes fonctions personnalisées selon la logique du programme et la division des tâches main() se préoccupe davantage de la logique métier et du flux de traitement, lorsque des tâches spécifiques. doivent être exécutés, appelez simplement ces fonctions personnalisées.
Afin de faciliter la compréhension, nous divisons les fonctions en deux types : l'une est une fonction de bibliothèque et l'autre est une fonction personnalisée.
Les fonctions de la bibliothèque sont fournies par le langage C ou le système. Elles implémentent certaines fonctions de base, telles que scanf et printf, et peuvent être utilisées directement dans le programme.
Les fonctions personnalisées sont des fonctions écrites par des programmeurs pour accomplir une certaine tâche. Le but est de réaliser une certaine fonction ou de rendre le programme principal plus concis. Les programmeurs doivent déclarer et définir des fonctions personnalisées avant de les utiliser.
La déclaration de fonction personnalisée consiste à indiquer au compilateur le nom de la fonction et comment appeler la fonction, y compris les données du valeur de retour de la fonction Type, nom de la fonction, liste des paramètres.
Certains programmeurs font également référence aux déclarations de fonctions comme des prototypes de fonctions, mais le libellé est différent, mais la signification est la même.
La syntaxe de déclaration d'une fonction en langage C est la suivante :
Retour value data Type return_type : Une fois la fonction terminée la tâche, elle peut renvoyer une valeur return_type est le type de données de la valeur renvoyée par la fonction, qui peut être int, char, double ou autre. types de données personnalisés. Certaines fonctions effectuent uniquement des tâches sans renvoyer de valeur. Dans ce cas, return_type est représenté par le mot-clé void.
La syntaxe de déclaration d'une fonction sans valeur de retour est la suivante :
Les noms des fonctions sont les identifiants et les règles de dénomination sont les mêmes que celles des noms de variables. Liste des paramètres de la liste des paramètres de la fonction :
Lorsque la fonction est appelée, l'appelant doit transmettre des valeurs aux paramètres de la fonction. La liste des paramètres comprend le type et l'ordre des paramètres. La liste des paramètres est facultative, c'est-à-dire que la fonction ne peut avoir aucun paramètre. La syntaxe de déclaration d'une fonction sans paramètres est la suivante :
Exemple de déclaration de fonction :
déclare une fonction, la valeur de retour est de type int, le nom de la fonction est checksc, la fonction n'a qu'un seul paramètre int height, notez que la fonction Le point-virgule à la fin de l'instruction de déclaration ne peut pas manquer. 
Si vous comparez une fonction personnalisée à un outil, la déclaration de fonction est le dessin de conception de l'outil.
La fonction personnalisée est un outil Si vous souhaitez que cet outil soit utilisé, il ne suffit pas d'avoir des dessins de conception, vous devez faire. l'outil. , la définition d'une fonction est l'entité de cet outil, fournissant le corps réel de la fonction. Afin de réaliser la fonction de la fonction, le programmeur écrit le code pour la fonction requise.
La syntaxe de définition de fonction en langage C est la suivante :
Le return_type, function_name et La liste des paramètres doit être cohérente avec la déclaration de la fonction.
Le corps de la fonction contient la collection d'instructions qui doivent être exécutées pour terminer la tâche, placées entre accolades.
Exemple :
Remarque, n'ajoutez pas de points après la fonction définition n°, ce qui suit est faux, et les débutants sont enclins à commettre cette erreur.
Si la fonction personnalisée est uniquement dans le programme appelant Utilisé dans le programme appelant, il peut être déclaré et défini dans le programme appelant. La déclaration se trouve généralement dans la partie supérieure du programme appelant, et la définition se trouve généralement dans la partie inférieure du programme appelant. le langage C, mais pour rendre le programme plus facile à lire. Style d'écriture convenu par les programmeurs.
Exemple de déclaration et définition de fonctions personnalisées dans le programme appelant (book45.c) :
Dans book45.c, la fonction checksc pour déterminer la figure d'une super fille n'est pas une fonction publique, elle n'est utilisée que par le projet de programme, elle est donc déclarée et définie dans le livre45.c.
Si la fonction personnalisée est un module de fonction public, comme comparer la taille de deux nombres, elle peut être déclarée dans d'autres fichiers d'en-tête (tels que _public.h), et l'appelant Le programme doit utiliser la directive de prétraitement #include pour inclure le fichier d'en-tête déclaré par la fonction.
Si la fonction personnalisée est un module de fonction public, elle peut être définie dans d'autres fichiers de programme (tels que _public.c lors de la compilation, le programme appelant et les fichiers de programme pour la personnalisation). les fonctions sont compilées ensemble.
Dans l'exemple suivant, la fonction max est déclarée dans le fichier d'en-tête _public.h, définie dans le fichier programme _public.c, et appelée dans le programme book46.c.
Fichier d'en-tête de la fonction personnalisée (_public.h) :
Fichier programme de la fonction personnalisée (_public.c) :
Fichier programme appelant (book46. c)
La commande de compilation est la suivante :
Remarque :
1) À la ligne 6 du livre46.c
,
Les fichiers d'en-tête inclus ici sont des guillemets doubles, et non des crochets angulaires . De manière générale, #include est utilisé pour inclure les fichiers d'en-tête des fonctions de bibliothèque fournies par le langage C, et #include "" est utilisé pour inclure les fichiers d'en-tête définis par le programmeur.
2) Lors de la compilation du programme appelant, compilez ensemble le programme appelant et le fichier programme de la fonction personnalisée. Sinon, l'erreur suivante se produira lors de la compilation.
L'instruction de compilation correcte doit être gcc -o book46 book46.c _public.c
3) Il n'y a aucune réglementation sur la dénomination des fichiers d'en-tête _public.h et _public.c des fonctions personnalisées. Ils sont nommés par le programmeur lui-même, tout comme la dénomination des variables afin d'augmenter la lisibilité. du programme, essayez de les nommer autant que possible. Utilisez des noms significatifs.
Le langage C fournit certaines fonctions déclarées et définies. L'appel de ces fonctions peut compléter certaines fonctions de base. Bibliothèque standard C (bibliothèque standard C), appelée fonctions de bibliothèque, telles que printf, scanf, memset, strcpy, etc. Il existe des centaines de fonctions de bibliothèque dans le langage CC, mais seulement deux à trois dixièmes d'entre elles sont couramment utilisées. Il n'est pas nécessaire de les mémoriser. Dans les chapitres suivants, je présenterai en détail l'utilisation de certaines fonctions de bibliothèque courantes. plus vous les utiliserez, plus vous vous familiariserez avec eux.
Le fichier d'en-tête déclaré de la fonction de la bibliothèque standard du langage C est stocké dans le répertoire /usr/include, comme suit :
<asset.h> <ctype.h> <errno.h> <float.h> <limits.h>
<locale.h> <math.h> <setjmp.h> <signal.h> <stdarg.h>
<stddef.h> <stdlib.h> <stdio.h> <string.h> <time.h>C fonction de bibliothèque de langage Le fichier de définition est /usr/lib/gcc/x86_64-redhat-linux/4.4.4/libgcc.a (le nom du répertoire de version des différents compilateurs est différent). Il s'agit d'un fichier de bibliothèque de liens statiques packagé. présentera la connaissance des bibliothèques de liens plus tard.
Nous n'avons pas inclus libgcc.a lors de la compilation du programme avec gcc, car le compilateur gcc l'inclura par défaut. Cependant, l'en-tête de la fonction définie par le programmeur Files et. les fichiers programme ne bénéficient pas de ce traitement et doivent être inclus manuellement.
Quand on utilise une fonction de bibliothèque, si on n'inclut pas son fichier d'en-tête, un avertissement apparaîtra lors de la compilation, comme suit :
Quels fichiers d'en-tête doivent être inclus ? Il existe deux méthodes. L'une consiste à rechercher des informations sur Baidu et l'autre consiste à utiliser l'aide fournie par le système Linux. En prenant la fonction strcpy comme exemple, saisissez man strcpy et appuyez sur Entrée sur la ligne de commande, comme suit :
man affiche le fichier d'en-tête de la déclaration de fonction (ligne 5), les paramètres, l'utilisation et la valeur de retour de la fonction.
Notez que si la fonction bibliothèque utilisée dans le programme n'inclut pas son fichier d'en-tête, il ne s'agit pas nécessairement d'un avertissement lors de la compilation, mais peut aussi être une erreur, la fonction ne peut pas être reconnu, etc. Cela dépend des compilateurs, les compilateurs pour différents langages C sont différents.
Les fonctions de bibliothèque sont déclarées et définies par le système et sont des outils prêts à l'emploi. Les fonctions personnalisées sont déclarées et définies par les programmeurs eux-mêmes, et sont des outils complétés par les programmeurs. Qu'il s'agisse d'outils disponibles dans le commerce ou d'outils supplémentaires, ce sont tous des outils, et ils sont identiques pour les utilisateurs, sans différence.
En langage C, les appels de fonctions sont très flexibles. Ils peuvent occuper une ligne d'instructions, être affectés à des variables comme constantes, ou être utilisés comme paramètres de fonctions.
Si la valeur de retour de la fonction est nulle, cela signifie que la tâche de la fonction est principalement de remplir une certaine fonction. Elle est généralement écrite sur une seule ligne et a une exclusivité. déclaration.
如果函数的返回值不是void，如果单行书写，表示不关心它的返回值，也可以当成常量用于任何表达式中。
例如：
当程序调用函数时，程序控制权会转移给被调用的函数。被调用的函数执行函数体的代码，当函数的返回语句被执行时，或到达函数的结束括号时，就把程序控制权交还给调用者程序。
示例（book47.c）
运行结果
关于函数的参数，在很多教程中有很多说法，如“形参”、“实参”、“值传递”、“地址传递”、“引用”等，这些说法把简单的概念复杂化了，大家不必理会。
函数的参数可以理解为函数的局部变量，参数传递就是调用者程序把变量（或常量）的值复制一份给函数的参数，简单说来就是复制的过程。一旦完成数据的复制，调用者程序的变量和函数的参数就再也没有瓜葛了，所以，在函数调用的过程中，函数的参数的值发生改变并不会影响调用者程序的变量的值。
我们在调用函数的时候，不关心函数参数的名称，函数参数的名称是函数自己的事情，只在函数内部使用，与调用者无关。
示例（book48.c）
运行结果
const 是 constant 的缩写，意思是“恒定不变的”！它是定义只读变量的关键字，或者说 const 是定义常变量的关键字。用 const 定义常变量的方法很简单，就在通常定义变量时前面加 const 即可，如：
const int a = 10;
那么用 const 修饰后和未修饰前有什么区别呢？它们不都等于 10 吗？
用 const 定义的变量的值是不允许改变的，即不允许给它重新赋值，即使是赋相同的值也不可以。所以说它定义的是只读变量。这也就意味着必须在定义的时候就给它赋初值。
在变量前加const约束，主要用于定义函数的参数，表示该参数在函数中是只读取，不允许改变，如果函数中试图改变它的值，编译的时候就会报错。
例如：
函数max在声明的时候，参数a和b都加了const约束，在函数中，a=10;和b=20;这两代码试图改变a和b的值。编译的时候如下：
编译无法通过。
在我的课程中，会介绍常用的库函数，但也有漏掉的。查资料是程序员的基本技能。
例如要查找C语言复制字符串功能的函数，在百度上输入“C语言复制字符串”搜索就可以了，你想查什么就输入什么。
然后，打开多几个网页看看，基本上就差不多了。
注意一个问题，网上的内容太多太杂乱，重点关注百度百科的文章。
1）测试函数的功能
要使用函数，只需要关注它需要包含的头文件、函数名、返回值、参数的数据类型和参数的顺序，不必关心参数的名称。
以strcpy函数为例，函数的声明如下。
char *strcpy(char *dest, const char *src);
函数名：strcpy
返回值：返回dest，一般没用，不理它。
第一个参数是目标字符串；第二个参数是源字符串，有const约束。
写代码测试一下：
char strname[50];
strcpy(strname,"西施");
printf("=%s=\n",strname);然后，看看输出的结果是不是“=西施=”，用=号夹住输出的内容是为了看清楚有没有其它的字符。
感谢大家的阅读，希望大家收益多多。
本文转自：https://blog.csdn.net/wucz122140729/article/details/98369860
推荐教程：《C语言》
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!
Nom des variables en langage C
Auto-apprentissage pour débutants en langage C sans fondement
Ordre de priorité des opérateurs en langage C
Structure de données en langage C
Utilisation des fonctions aléatoires du langage C
utilisation du langage c const
Utilisation de la fonction get en langage C
méthode d'initialisation du tableau c
![[Web front-end] Démarrage rapide de Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
