Quelle est l'utilité d'utiliser

l'utilisation est la suivante : 1. Espace de noms [en utilisant l'espace de noms]; 2. Tapez alias [en utilisant aa=double] 3. Changez le niveau d'accès des membres hérités de la classe de base 4. Laissez le dérivé ; la classe est visible par toutes les fonctions surchargées de la classe de base ; 5. Laissez la classe dérivée hériter de tous les constructeurs.

[Recommandations d'apprentissage associées : Vidéo du didacticiel du langage C]

l'utilisation est :

1 Espace de noms

using namespace 命名空间;//这样每次使用命名空间中的变量时就不用指定命名空间了

Remarque : il ne devrait pas y avoir d'utilisation dans l'en-tête. Déclaration d'espace de noms de fichier

2. Type alias (C++11)

using aa = double;//等价于typedef double aa
typedef double db, *p;//db是double的同义词，p是double*的同义词（注意）

3. Changer le niveau d'accès des membres hérités de la classe de base

class base {
public:
    int fun(int x);
    int b;
};
class son : private base {
public:
    using base::fun;    //fun(int x)由private变成public（注意：using不指定参数列表）
protected:
    using base::b;    //b由public变成protected
};

4. Rendre la classe dérivée visible pour toutes les fonctions surchargées de la classe de base au lieu de la cacher

class base {
public:
    void func()
    {
        cout << "func1()" << endl;
    }
    void func(int x)
    {
        cout << "func2()" << endl;
    }
};
class son : public base {
public:
    using base::func;    //若没有此句，func()和func(int x)将会被隐藏
    void func(int x, int y)
    {
        cout << "func()3" << endl;
    }
};

5. Mise à niveau du point 4, en utilisant l'autorisation. la classe dérivée pour hériter de tous les constructeurs de la classe de base directe

1) La classe dérivée n'hérite pas des constructeurs de la classe de base de la manière conventionnelle, mais utilise l'instruction using pour laisser la classe dérivée class hériter de Tous (à deux exceptions près) les constructeurs de la classe de base

2) Exception 1 : Si le propre constructeur de la classe dérivée a les mêmes paramètres formels qu'un constructeur de la classe de base, alors le constructeur ne sera pas hérité

Exception 2 : les constructeurs par défaut, de copie et de déplacement ne seront pas hérités

3) Contrairement au point 3, l'instruction using ne modifiera pas le niveau d'accès du constructeur hérité : peu importe d'où vient l'instruction using apparaître ? Le constructeur public/protected/private de la classe de base est toujours un constructeur public/protected/private dans la classe dérivée

4) L'instruction using ne peut pas spécifier explicit et constexpr : if la base If le constructeur. d'une classe est explicite ou constexpr, le constructeur hérité a également les mêmes attributs

5) Le constructeur hérité n'est pas un constructeur personnalisé, il peut donc toujours répondre aux règles de génération des constructeurs synthétiques

6) Si le constructeur de la classe de base a des paramètres réels par défaut, les paramètres par défaut réels ne seront pas hérités

7) Si le constructeur de la classe de base a deux paramètres formels et qu'un paramètre formel ne l'est pas Si l'autre Le paramètre formel a des paramètres réels par défaut, alors deux constructeurs seront obtenus par héritage : un constructeur a deux paramètres formels et l'autre n'a qu'un seul paramètre formel (correspondant à celui sans paramètres réels par défaut). sera hérité

class base {
public:
    base() {}
    base(string s, int a) {}
};
class son : public base {
public:
    using base::base;//继承直接基类所有的构造函数，对于基类的每个构造函数，编译器都在派生类中生成一个形参完全相同的构造函数
　　//using不能指定explicit和constexpr
private:
    //使用继承来的构造函数时，如果派生类有自己的数据成员，则这些成员将被默认初始化
    string str;
    int num;
};
//等价于：
class son : public base {
public:
    son():base() {}
    son(string s, int a): base(s, a) {}
};

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!