1. Traiter C++ comme une association multilingue

Le nom original de C++ était C avec classes, ce qui signifie qu'au début, C++ n'était que C plus quelques fonctionnalités orientées objet.

C++ est maintenant un langage de programmation multiparadigme. Prend également en charge :

1) Formulaire procédural (procédural)

2) Formulaire orienté objet (orienté objet)

3) Forme fonctionnelle (fonction)

4) Forme générique (générique)

5) Formulaire de métaprogrammation (métaprogrammation)

Le C++ peut être divisé en quatre parties principales :

1 ) C C++ est basé sur C. Les blocs, les instructions, le préprocesseur, les types de données intégrés, les tableaux, les pointeurs, etc. proviennent tous de C.

2) Orienté objet (orienté objet) . Cette partie est du C avec des classes, y compris : classes (constructeur et destructeur), encapsulation, héritage, polymorphisme, fonction virtuelle (liaison dynamique) et ainsi de suite.

3) Modèle (modèle) . C'est la forme générique du C++. Il est puissant et apporte un nouveau générique de programmation, qui est la métaprogrammation dite par template (TMP, template metaprogramming).

4) STL (Standard Template Library, bibliothèque de modèles standard) . Les conteneurs, les itérateurs, les algorithmes et les objets fonctionnels sont intégrés.

Lors de l'utilisation de différentes pièces, différentes conventions de programmation peuvent devoir être suivies.

2. Essayez de laisser le compilateur remplacer le préprocesseur

Lors de l'écriture de programmes, essayez de remplacer #define par const, enum, inline

1）const

Le code suivant :

#define rate 1.63

Tous les taux seront remplacés par 1,63 lors du prétraitement du code. Lors de la compilation, le nom de la variable taux n'est pas entré dans la table des symboles. Ainsi, lorsque vous rencontrez un message d'erreur de compilation causé par l'utilisation de cette constante, le message d'erreur peut contenir 1,63 au lieu de taux. Si rate est défini dans un fichier d'en-tête que vous n'avez pas écrit, vous aurez du mal à localiser l'erreur. Il vaut mieux le remplacer par le code suivant :

const double rate = 1.63

À ce stade, rate est utilisé comme une constante et entrera dans la table des jetons lors de la phase de compilation. De plus, à un moment donné, l'utilisation de constantes peut économiser plus d'espace que #define, car le préprocesseur remplace "aveuglément" tous les débits par 1,63, ce qui peut entraîner plusieurs 1,63 dans le code objet, et l'utilisation de constantes ne se produit pas.

Deux cas particuliers sont à noter :

1) Définissez des pointeurs constants et des constantes de pointeur.

a = 10;
b = 20;

const int *p1 = &a; //特点：指针的指向可以修改，指针指向的值不可以修改
// *p1 = 30;  指针指向的值不可以修改
p1 = &b; //指针的指向可以修改

int *const p2 = &a; //特点：指针的指向不可以修改，指针指向的值可以修改
*p3 = 30; //指针指向的值可以修改
// p3 = &b;    //指针的指向不可以修改

2) Constantes spécifiques à la classe. Afin de limiter la portée de la constante à la classe, elle doit être appelée membre de la classe. Afin de s'assurer qu'il existe au plus une copie de la constante, elle doit être déclarée comme membre statique.

membres statiques statiques : variables membres statiques, fonctions membres statiques

Variable de membre statique :

1. Tous les objets partagent les mêmes données

2. Allouer de la mémoire lors de la compilation

3. Déclaration en classe, initialisation hors classe

Fonction membre statique :

1. Tous les objets partagent la même fonction

2. Les fonctions membres statiques ne peuvent accéder qu'aux variables membres statiques

class person{
public:
    //类内声明
    static int age;
    int a;
    //静态成员函数
    static void func(){
        age = 150;
        //a = 100;// 静态成员函数只能访问静态成员变量,无法区分是哪个对象的成员
        cout << "静态成员函数"  << age << endl;
    }
};
//类外初始化
int person::age = 100;

Soit dit en passant, #define ne peut fournir aucune encapsulation, et sa plage effective se situe entre #define et #undef, et elle prend effet pour le processus.

2）énumération

Dans le cas où vous auriez besoin de définir la valeur initiale dans la classe (comme définir la taille du tableau), vous pouvez utiliser le hack enum, dont la base théorique est "un int énumérable vertical de type énuméré (type énuméré) est utilisé ". Ainsi, le code peut être défini comme suit :

class Group{
publice:
    enum {num = 10};
    int person[num];
};

(L'utilisation d'enum peut être vue dans le blog de type d'énumération C++ (enum)_Peng sur la même table-CSDN blog_c++ enum )

3) en ligne

Une autre mauvaise utilisation courante de #define est de l'utiliser pour implémenter des macros.

Les macros ressemblent à des fonctions, mais sans entraîner la surcharge d'un appel de fonction.

#define func(a,b) ((a) > (b) ? (a) : (b))

int main() {
    for (int i = 0 ; i < 10 ; i++) {
        cout << i << "<=" << func(i, i + 1) << endl;
    }
    // 0<=1 1<=2 2<=3 3<=4 4<=5 5<=6 6<=7 7<=8 8<=9 9<=10

    return 0;
}

Dans l'exemple ci-dessus, l'endroit où func(a, b) est appelé à l'intérieur de chaque boucle for est remplacé par ((a) > (b) ? (a) : (b)), évitant ainsi les appels fréquents La consommation causée par le développement répété de la mémoire de la pile par la fonction.

Mais utiliser #define pour définir des macros peut causer beaucoup de problèmes. Chaque fois que vous utilisez une macro, vous devez mettre des parenthèses autour de tous les arguments de la macro, sinon vous rencontrerez parfois des problèmes. Mais même si vous ajoutez des parenthèses, les problèmes suivants se produiront :

#define func(a,b) ((a) > (b) ? (a) : (b))

int main() {
    int a = 5;
    int b = 0;
    cout << func(++a,b) << " a:" << a << endl;
    // 7 a:7    a被累加2次

    a = 5;
    b = 0;
    cout << func(++a,b + 10) << " a:" << a << endl;
    // 10 a:6   a被累加1次

    return 0;
}

Ici, après avoir appelé func(a, b), le nombre d'incréments de a dépend de qui il est comparé. Lorsque a = 5 est comparé à b = 0, lorsque (a) > (b), a est incrémenté une fois, et lorsque (a) est sorti, a est à nouveau incrémenté ; lorsque a = 5 est comparé à b + 10 = 10 , lorsque (a) > (b), a est incrémenté une fois, et lors de la sortie de (b), a n'est plus incrémenté.

À ce stade, vous pouvez utiliser des fonctions en ligne de modèle pour obtenir l'efficacité des macros et tout le comportement prévisible et la sécurité de type des fonctions normales.

template <class T>
inline const T func(T a,T b) {
    return a > b ? a : b;
} 

int main() {
    int a = 5;
    int b = 0;
    cout << func(++a,b) << " a:" << a << endl;
    // 6 a:6   

    a = 5;
    b = 0;
    cout << func(++a,b + 10) << " a:" << a << endl;
    // 10 a:6   

    return 0;
}

À ce stade, il n'est pas nécessaire d'ajouter des parenthèses aux paramètres dans le corps de la fonction, et il n'est pas nécessaire de s'inquiéter du fait que les paramètres sont calculés plusieurs fois, etc.

De plus, func () est une fonction réelle, qui obéit aux règles de portée et d'accès. À ce stade, vous pouvez l'utiliser comme une fonction privée dans la classe. En règle générale, les macros ne peuvent pas le faire.

De plus, un modèle peut générer tout un tas de fonctions, chacune pouvant accepter deux objets du même type .

(inline : utilisation en ligne en C++ | tutoriel pour les débutants )

(modèle : modèle C++——template_original 45 blog-CSDN blog_c++ template )

Avec const, enum, inline, notre besoin de préprocesseur (en particulier #define) est réduit, mais pas complètement éliminé, il est toujours nécessaire, et #ifdef / #ifndef continuent également à jouer un rôle important dans le contrôle de la compilation.

( Explication détaillée de l'utilisation et de la fonction de #ifdef et #endif dans le Blog-CSDN Blog_endif de C++_inCorning )

3. Résumé

1. C++ est déjà un langage de programmation multi-générique. Lorsque vous utilisez différentes parties de C++, vous devrez peut-être suivre différentes spécifications de programmation.

2. Pour les constantes simples, il est préférable de remplacer #define par des objets const ou des énumérations.

3. Pour les macros de type fonction (macros), il est préférable d'utiliser des fonctions en ligne au lieu de #define.

(1) Première connaissance du C++