L'utilisation de locaux de classe en C++ la fonction

Je vois un certain usage interne struct en c++ la fonction.

Il y a une interface commune IBase. Voici le projet de code.

class IBase
{
    virtual Method()=0;
}

vector<IBase*> baseList;

Alors une fonction définie une classe interne basé sur cette IBase, puis poussez l'intérieur de la classe de l'objet dans le baseList.

void func()
{
    struct Object : public IBase
    {
        virtual Method()
        {
            //Method of Object in func
        }
    }

    IBase* base = new Object();
    baseList->push(base);

}

Il semble étrange d'utilisation, mais une bonne mise en œuvre de message/événement de création de modèle.

Autres threads peut-être utiliser cette baseList pour gérer l'événement entrant.

Quelle est la portée de l'interne de la structure de "struct Objet"? C'est très intéressant. S'il y a des documents à parler à ce sujet?

InformationsquelleAutor giggle | 2011-04-19

c++design-patterns

45

Quelle est la portée de l'interne de la structure de "struct Objet"?

La portée des classes locales est la fonction dans laquelle elles sont définies.Mais ce n'est pas intéressant en soi.

Ce qui rend les classes intéressant, c'est que si ils mettent en œuvre une interface (comme votre code ne), vous pouvez ensuite créer des instances de celui-ci (à l'aide de new) et les retourner (par exemple, comme std::vector<IBase*>), ce qui fait la mise en œuvre accessible à travers la base de pointeur de classe même en dehors de la fonction.

Certains autres faits concernant les classes locales:
- Ils ne peuvent pas définir de membre statique des variables.
- Ils ne peuvent pas accéder non "automatique" des variables locales de la fonction englobante. Mais ils peuvent accéder à la static variables.
- Ils peuvent être utilisés dans le modèle de fonctions.
- Si ils sont définis à l'intérieur d'un modèle de fonction, ils peuvent utiliser les paramètres du modèle de la fonction englobante.
- Classes locales sont finales, ce qui signifie que les utilisateurs en dehors de la fonction ne peut pas dériver de classe locale à la fonction. Sans classes locales, vous devez ajouter un sans nom d'espace de noms séparés de l'unité de traduction.
- Locaux de classes sont utilisées pour créer trampoline fonctions généralement connu sous le nom thunks.
MODIFIER

Quelques références de la Norme (2003)

9.8 Local déclarations de classe [classe.local]

\1. Une classe peut être définie dans une définition de fonction; une telle classe est
appelé un local de classe. Le nom d'un
classe locale est locale à son enveloppant
la portée. La classe locale est dans le champ d'application
du cadre englobant, et a la
même l'accès aux noms en dehors de la
la fonction que ne l'enfermant
fonction. Les déclarations dans un local
la classe peut utiliser uniquement les noms de type statique
les variables, les variables extern et
les fonctions et les agents recenseurs de la
cadre englobant.
```
[Example:

int x;
void f()
{
   static int s ;
   int x;
   extern int g();

   struct local {
      int g() { return x; } //error: x is auto
      int h() { return s; } //OK
      int k() { return ::x; } //OK
      int l() { return g(); } //OK
   };
//...
}
local* p = 0; //error: local not in scope

—end example]
```
\2. Une fonction englobante n'a pas d'accès spécial aux membres de la section locale
classe; il obéit à l'habitude des règles d'accès
(clause 11). Des fonctions de membre d'un
local de classe doit être définie à l'intérieur de
leur définition de la classe, s'ils sont
tout défini.

\3. Si la classe X est une classe d'une classe imbriquée Y peut être déclarée dans
la classe X et plus tard définis dans le
définition de la classe X ou plus tard
défini dans le même champ d'application que l'
définition de la classe X. Une classe imbriquée
dans un local de classe est une classe locale.

\4. Un local de classe ne doit pas avoir des données membres statiques.
- * Ils ne peuvent pas accéder non statique des variables locales. Cela signifie que le correcteur de fonction virtuelle ne peut pas accéder à la variable locale?
- Pas directement, mais vous pouvez les passer comme arguments au constructeur, de sorte que le virtual fonctions peuvent les utiliser.
- Juste pour clarifier, le remplacement de fonction virtuelle peut bien sûr déclarer et d'accéder à ses propre variables locales. Nawaz signifiait que les variables locales de func().
- Merci pour l'ajout que. 🙂
- Tout document parle de ce schéma? 🙂
- Oui. Modern C++ Design parle de cela au moins en deux endroits, d'abord dans la section 2.3 du chapitre 2, et la deuxième dans le chapitre 11.
- Il est intéressant de noter que les fonctions locales pas être utilisés comme arguments de modèle sous C++03.
- "Classes locales sont finales" - N'est-ce pas un peu trompeur? Un local de classe peut dériver d'une autre classe locale définie dans la même fonction.
InformationsquelleAutor Nawaz

\4. Un local de classe ne doit pas avoir des données membres statiques.

MAIS vous pouvez le faire, à l'intérieur d'un local de classe

int GetCount()
{
    class _local
    {
    public:
        static int Count(int count = std::numeric_limits<int>::max())
        {
            static int count_ = 0;
            if (count != std::numeric_limits<int>::max()) count_ = count;
            return count_;
        }

        static float Operation(float  a, float  b)
        {
            _local::Count(_local::Count() + 1);
            return a;
        }
    };
   _local::Count(0);
   CALLBACK( _local::Operation);
   return _local::Count();
}

_local::nombre peut être utilisé pour lire et écrire le contraire variable statique

-aydin

C'est très intéressant d'utiliser une méthode pour entourer une valeur. Set/get dans une méthode. static int Count(int count = -1) { static int count_ = 0; if (count != -1) count_ = nombre; return count_; }

InformationsquelleAutor aydin

2

C'est normal C++. Le portée de struct Object est uniquement la fonction func. Cependant, vous pouvez toujours utiliser des objets de ce type sans savoir de quel type de béton qu'ils sont, puisqu'ils héritent de IBase. Ce est utilisé pour encapsuler la mise en œuvre.

InformationsquelleAutor Lindydancer
0

Une utilisation très intéressante d'une classe locale est présenté par Jason Turner dans son CppCon parler axé sur des programmes de Commodore 64 jeu en C++17. Il montre comment utiliser le RAII principe sur le niveau de la fonction.

Fondamentalement il établit des invariants dans le constructeur d'une classe locale dans une fonction retournant une instance de cette classe. Les invariants de la durée est donc contrôlée par la durée de vie de l'objet retourné. Il est assez similaire à ce que RAII wrappers comme std::lock faire, il suffit de légèrement différent.

Vous pouvez voir la partie appropriée ici, mais je amour sa performance et recommande de voir tout le chemin à travers.

InformationsquelleAutor neonxc

Vous devez vous connecter pour publier un commentaire.

9.8 Local déclarations de classe [classe.local]