Nested class access

Bonsoir,

Je n'arrive pas à trouver comment je peux faire dans le cas suivant :

Imaginons :

Class A
{
Private :
Int *mavar;

Public :
Class iterateur_de_a
{
//Je voudrais pouvoir accéder a la variable mavar
}
}

Est-ce possible ?
j'ai essayé protected a la place de Private, mais ça ne semble pas changer grand chose.

  Qui ne tente rien...
  Ne risque pas d'avoir grand chose !!!

Pourquoi as-tu besoin de ce mécanisme ? C'est étrange. Si tu veux créer un iterator et si mavar représente la position, cet attribut devrait plutôt être dans la classe iterateur_de_a, non ?
Je serais curieux de savoir à quoi tu vas appliquer cela.

Pour répondre techniquement à ta question:
Même si c'est une inner classe, une classe ne fait pas partie d'une autre. C'est juste la visibilité qui change, et rien d'autre. Donc il te faut un moyen d'interaction.
Par exemple:


Tu noteras que tu pourrais très bien avoir 2 objets de type InnerClass.

________________________________________________________________________
Historique de mes créations, et quelques articles:
http://0217021.free.fr/portfolio
Merci d'utiliser Réponse acceptée si un post répond à votre question

Merci pour la réponse.

Je vais préciser d'avantage ce que je suis en train de faire.

Je code une class skip list.
Class skiplist
{
Private :
struct node
{
node **nexts;
string key;
void *value;//en fait c'est en te plate, mais je simplifie ici.
}
node *first;
public :
Class iterator
{
node * current;
}
}

Mon but est donc de pouvoir itérer la skip liste, mais je ne veut pas qu'il y ai un moyen pour que quelqu'un d'autre que skiplist ou iterator ai connaissance de node.


  Qui ne tente rien...
  Ne risque pas d'avoir grand chose !!!

Si tu cherches à réaliser une liste chaînée, inutile de réinventer la roue.
Tu as: std::list pour une liste doublement chaînée, et std::forward_list pour une liste simplement chaînée.

En C++, il y a plusieurs réflexes à avoir. Lors que tu vois certaines choses dans un code, tu peux être sur que c'est louche. Ces signes sont:
- Utilisation d'un void* (Très très louche)
- Utilisation d'un ** (Très très louche)
- Utilisation d'un * (louche bien que possible)
- string au lieu de std::string (moyen, Évite les "using namespace", voir: [ Lien ])

De plus, par convention (totalement libre à toi de la suivre, ce n'est qu'une convention):
- Une classe commence par une majuscule (Pascal Case)
- Un attribut de classe est différencier des autres (par exemple en le précédent d'un '_').
- Méthode et variable sont en général en Camel Case.
- L'étoile ou la référence touche le type, et non la variable (contrairement au C).

________________________________________________________________________
Historique de mes créations, et quelques articles:
http://0217021.free.fr/portfolio
Merci d'utiliser Réponse acceptée si un post répond à votre question

En fait, il s'agit bien ici d'une skip list et non d'une liste chainée, c'est pour ça que j'ai besoins de mon node**, puisque la skip list contient finalement un nombre pour le moment inconnu de liens vers les suivantes.

Le void* value, ce n'est pas ce que j'ai mis dans le code, mais la je suis sur ma tablette et j'avoues que c'est relativement chiant de rédiger (correcteur auto et autres inconvénients), donc je n'ai pas mis les templates.

Mais, il est donc impossible que la classe interne ait accès a un membre de la classe de base, sans pour autant donner cet accès en openbar (public) ?

  Qui ne tente rien...
  Ne risque pas d'avoir grand chose !!!

J'oublie, autant préciser, j'ai regardé Std::map (une red black grée en fait), j'ai vérifié et certains recommandent plutôt la skip list.

  Qui ne tente rien...
  Ne risque pas d'avoir grand chose !!!

node** => Juste pas possible en C++ (conceptuellement, pas techniquement). Il y a forcément un souci de conception quand tu vois ça. std::vector ou std::list à la place.
Prend aussi la bonne habitude de remplacer les pointeurs pas des références dès que c'est possible, ou par des smart pointers.


Tu confonds classe et objet. Une classe n'est pas du code. C'est une moule qui décrit un objet. Tout comme une structure en C. Est-ce qu'en C tu te demanderais si une structure interne peut accéder aux champs de sa structure mère ? Non, car il n'y a pas de valeurs dans une structure, il n'y en a uniquement si tu crées une structure de ce type. Donc tu as bien accès à une variable, mais à condition d'en avoir une instance (un objet si tu préfères). Quand tu crées une classe interne, c'est comme si tu déclarait une classe normale, mais dont l'amitié serait automatique (mot clé "friend").


En quoi est-ce gênant ? Une classe interne à tout intérêt à avoir accès à sa classe mère, non ? Le fait que la classe interne voit sa classe mère publiquement, ne veux pas dire pour autant que toutes les classes verront celles-ci publiquement à leur tour.


Si tu te questionnes sur une std::map ou une skip list, alors c'est que tu as besoin d'accéder rapidement à un élément. Je ne suis dans ce cas pas vraiment convaincu par une skip list. Si tu recherches une collection à accès rapide, alors je te conseille plutôt une std::unordered_map (ou std::unordered_multimap selon les besoins). C'est une table de hash donc à accès O(1).

________________________________________________________________________
Historique de mes créations, et quelques articles:
http://0217021.free.fr/portfolio
Merci d'utiliser Réponse acceptée si un post répond à votre question

Utiliser un vector a la place du **... en effet c'est une solution, mais ça risque pas d'être lourd en comparaison ?
Sachant que le ** veut ici seulement dire qu'on ne connait la taille que a l'allocation, en dehors de ça elle est fixe !

Sinon, merci, c'est la notion de friend qui me manquait. Quand je disait public, c'était bien vis a vis de tout le monde !

Concernant la hash table, en effet pourquoi pas, mais la question était aussi présente pour l'apprentissage du fonctionnement des nested classes (ya pas un équivalent francais ?).

Merci pour tes réponses

  Qui ne tente rien...
  Ne risque pas d'avoir grand chose !!!