Chapitre 6 C++ : principes de base des fonctions et applications

Chapitre 6 Fonctions

Une fonction est un bloc de code nommé qui exécute le code correspondant en appelant la fonction.

Bases des fonctions

• Exécuter des fonctions via l'opérateur d'appel (opérateur d'appel). Sa forme est une paire de parenthèses. L'appel de la fonction

• termine deux tâches (comme indiqué ci-dessous, l'exécution de la fonction d'appel principale (fonction d'appel) est temporairement interrompue. , et la fonction appelée (appelée fonction) ) démarre l'exécution.

• Initialisez les paramètres formels correspondant à la fonction avec les paramètres réels.

• Transférer le contrôle à la fonction appelée.

• return déclaration :

• Renvoyer la valeur dans la déclaration return

•  Déplacer le contrôle de la fonction appelée vers la fonction appelante

Objet local

• Le nom a une portée, l'objet a

  Durée de vie (durée de vie)

• Objet automatique (objet automatique) : Cet objet est créé lorsque le chemin de contrôle de la fonction passe par l'instruction de définition de variable . Détruisez-le lorsque la fin du bloc dans lequel il est défini est atteinte.

• Objet statique local : Il est initialisé lorsque le chemin d'exécution du programme passe par l'instruction de définition d'objet pour la première fois, et n'est détruit qu'à la fin du programme.
  

• Définir les variables locales comme

  statique pour obtenir, par exemple : <br>//Fonction statistique count_calls ( ) Combien de fois a-t-il été appelé<code> <br>//统计函数count_calls ()被调用了多少次 <br>size_t count_calls () <br>{ <br>static size_t ctr = 0;  //调用结束后，这个值仍然有效 <br>return ++ctr; <br>} <br>int main() <br>{ <br>for (size_t i = 0; i != 10; ++i) <br>cout << cout_calls() << endl; <br>return 0; <br>} <br>size_t count_calls ()

  {
static size_t ctr = 0; //Une fois l'appel terminé, cette valeur est toujours valide
return ++ctr

}

int main()

{

for (size_t i = 0; i != 10; ++i)
• cout <<

  return 0; }

• Déclaration de fonction

• également appelée

  prototype de fonction

  (prototype de fonction)

• Les trois éléments de la fonction (
type de retour, nom de la fonction, type de paramètre formel

) décrivent l'interface de la fonction , et le nom du paramètre formel dans la déclaration de fonction Peut être omis.

Les fonctions doivent être déclarées dans le fichier d'en-tête et définies dans le fichier source.

Compilation séparée

prog -d -o ofile data0

Passage de paramètres

int main(int argc, char *argv[]) {...}
//或：
int main(int argc, char **argv) {...}

Si le paramètre formel est un type référence, il sera lié au correspondant paramètre réel ; sinon, copiez la valeur du paramètre réel et affectez-la au paramètre formel.
- Si la valeur d'un paramètre de référence n'a pas besoin d'être modifiée, il est préférable de la déclarer comme référence constante.

argc = 5;argv[0] = "prog";argv[1] = "-d";argv[2] = "-o";argv[3] = "ofile";argv[4] = "data0";argv[5] = 0;

main : Gestion des options de ligne de commande

En supposant que la fonction principale est située à l'intérieur de l'exécutable prog, nous pouvons transmettre les options suivantes au programme :

• Ces les commandes passent deux Un paramètre formel facultatif est passé à la fonction principale :
  

Lorsque le paramètre réel est passé à la fonction principale, le premier élément de argv pointe vers le nom du programme ou une chaîne vide , et les éléments suivants sont Passer les arguments fournis par la ligne de commande. Le dernier pointeur supprimera uniquement la valeur de l'élément et est garanti égal à 0.
- Prenons comme exemple la ligne de commande ci-dessus :

1. Fonction avec paramètres variables

2. Le nouveau standard C++11 propose deux méthodes d'écriture function Fonctions qui gèrent différents nombres d'arguments :
Tous les arguments sont du même type, et un type de bibliothèque standard appelé initializer_list peut être transmis.

• Avec différents types de paramètres réels, nous pouvons écrire une fonction spéciale appelée modèle de paramètre variable.
  

• C++ a également un type de paramètre spécial : les points de suspension. Vous pouvez l'utiliser pour transmettre un nombre variable de paramètres réels. Cette fonction n'est généralement utilisée que pour les programmes d'interface qui interagissent avec les fonctions C.

• paramètre formel initializer_list
  <br/>initializer_list<T> lst; //默认初始化，T类型元素的空列表 <br/>initializer_list<T> lst{a,b,c...}; <br/>//lst的元素数量和初始值一样多；lst的元素是对应初始值的副本；列表中的元素是const <br/>lst2(lst) <br/>lst2 = lst //拷贝或复制一个initializer_list对象不会拷贝列表中的元素；拷贝后，原始列表和副本元素共享 <br/>lst.size() //列表中元素的数量 <br/>lst.begin() //返回指向lst中首元素的指针 <br/>lst.end() //返回指向lst中尾元素下一位置的指针 <br/>

Le type est défini dans le fichier d'en-tête avec le même name

• fournit les opérations suivantes :

  </li>initializer_list<T> // Initialisation par défaut, liste vide d'éléments de type T<li>initializer_list<T> ; lst{a ,b,c...}; <p>//Le nombre d'éléments de lst est égal à la valeur initiale ; les éléments de lst sont des copies des valeurs initiales correspondantes dans la liste ; const <strong>lst2(lst) </strong> lst2 = lst //La copie ou la copie d'un objet initializer_list ne copiera pas les éléments de la liste ; après la copie, la liste d'origine et les éléments copiés partagent</p>lst.size() //Le nombre d'éléments dans la liste</li>lst.begin( ) //Renvoie un pointeur vers le premier élément de lst </ul>lst.end() //Renvoie un pointeur vers la position suivante du dernier élément de lst <h4>

  • Type de retour et instruction de retour<🎜><🎜><🎜><🎜>La référence renvoie la valeur, les autres types de retour obtiennent la valeur r. <🎜><🎜><🎜><🎜><🎜>Valeur de retour d'initialisation de la liste<🎜> : Le nouveau standard C++11 stipule que les fonctions peuvent renvoyer une liste de valeurs entourées d'accolades. <🎜><🎜><🎜><🎜>La valeur de retour de la fonction principale main<🎜><🎜><🎜><🎜>La fonction principale est autorisée à n'avoir aucune valeur de retour (sinon, le compilateur insère implicitement retourner 0)< 🎜>

  • 返回0表示执行成功，其他值依机器而定。

  • 为了使返回值与机器无关，cstdlib头文件定义了两个预处理变量，分别表示成功和失败：
    <br/>return EXIT_FAILURE; <br/>return EXIT_SUCCESS; <br/>//因为它们是预处理变量，所以既不能在前面加上std::，也不能在using声明里出现。 <br/>

  返回数组指针

  1. 使用类型别名
     <br/>typedef int arrT[10]; //arrT是一个类型别名，它表示的类型是含有10个整数的数组 <br/>using arrT = int[10]; //与上一句等价 <br/>arrT* func(int i); //func返回一个指向含有10个整数的数组的指针 <br/>

  2. 声明一个返回数组指针的函数，形式如下
     <br/>Type (*function(parameter_list)) [dimension] <br/>//Type表示返回的数组指针指向的数组元素类型 <br/>//dimension表示数组的大小 <br/>//例如： <br/>int (*func(int i)) [10]; <br/>

  3. 使用尾置返回类型（C++11）
     <br/>auto func(int i) -> int(*)[10]; <br/>

  4. 使用decltype
     <br/>int odd[] = {1,3,5,7,9}; <br/>int even[] = {0,2,4,6,8}; <br/>decltype(odd) *arrPtr(int i) <br/>{ <br/> return (i % 2) ? &odd : &even; //返回一个指向数组的指针 <br/>} <br/>

  函数重载

  如果同一作用域内的几个函数名字相同但形参列表不同，我们称之为重载（overloaded）函数。

  • 不允许两个函数除了返回类型外其他所有要素都相同。

  • 重载与作用域：一旦在当前作用域中找到了所需的名字，编译器就会忽略掉外层作用域中的同名实体。

  特殊用途语言特性

  介绍三种函数相关的语言特性：默认实参、内联函数、constexpr函数。

  默认实参

  • 调用包含默认实参的函数时，可以包含该实参，也可以省略该实参。

  • 一旦某个形参被赋予了默认值，它后面所有的形参都必须有默认值。

  内联函数（inline）

  调用函数一般比求等价表达式的值要慢，内联函数可避免函数调用的开销。
  - 将函数指定为内联函数，通常就是将它在每个调用点上“内联地”展开。

  constexpr函数

  • 函数的返回类型和所有的形参类型都得是字面值类型。

  • 函数中必须有且只有一条return语句。

  • constexpr函数被隐式地指定为内联函数。

  内联函数和constexpr函数通常定义在头文件中

  调试帮助

  程序可以包含一些用于调试的代码，但这些代码只在开发程序时使用。当应用程序编写完成准备发布时，要先屏蔽掉调试代码。这种方法用到两项预处理功能：assert和NDEBUG。

  assert预处理宏

  #include <cassert>assert(expr);//首先对expr求值，//如果表达式为假（即0），assert输出信息并终止程序的执行。//如果表达式为真（即非0），assert什么也不做。//例如：对一个文本进行操作的程序可能要求所给定单词的长度都大于某个阈值。assert(word.size() > threshold;

  NDEBUG预处理变量

  • assert的行为依赖于一个名为NDEBUG的预处理变量的状态。如果定义了NDEBUG，则assert什么也不做。默认状态下没有定义NDEBUG，此时assert将运行执行时检查。
    

  • 使用#define语句定义NDEBUG，从而关闭调试状态。

  • 很多编译器都提供了命令行选项使我们可以定义预处理变量。
    <br/>$ CC -D NDEBUG main.C #微软编译器中用 /D <br/>

  • 这只是调试程序的辅助手段，不能代替真正的逻辑检查，也不能代替程序本应该包含的错误检查。

  • 除了assert以外，也能使用NDEBUG编写自己的条件调试代码：

  //如果定义了NDEBUG，#ifndef和#endif之间的代码将被忽略void print(const int ia[], aize_t size)
  {    #ifndef NDEBUG
          //_ _func_ _是编译器定义的一个局部静态变量，用于存放函数的名字，它是const char的一个静态数组。
          cerr << _ _func_ _ << "array size is " << size << endl;    #endif}

  除了_ _ func _ _之外，还有其它四个名字：

  _ _FILE_ _ 存放文件名的字符串字面值
  _ _LINE_ _ 存放当前行号的整型字面值
  _ _TIME_ _ 存放文件编译时间的字符串字面值
  _ _DATA_ _ 存放文件编译日期的字符串字面值

  函数指针

  bool lengthCompare(const string &, const string &);//pf指向一个函数，该函数的参数是两个const string的引用，返回值是bool类型。注意圆括号必不可少bool (*pf) (const string &, const string &);    //未初始化

  当我们把函数名作为值使用时，该函数自动地转换成指针

  pf = lengthCompare;     //pf指向名为lengthCompare的函数pf = &lengthCompare;    //等价赋值语句，&是可选的

  调用该函数：

  //此三个调用等价bool b1 = pf("hello", "goodbye");bool b2 = (*pf)("hello", "goodbye");bool b3 = lengthCompare("hello", "goodbye");

  参考：C++Primer第五版

  相关文章：

  第四章C++：表达式概念-运算符的应用

  Chapitre 5 C++ : Introduction aux instructions

  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!