Retourner l'adresse d'une structure

Version imprimable

10/05/2006, 18h54
insomniak

Retourner l'adresse d'une structure

Bonsoir.

Comment faire pour qu'un fonction retourne l'adresse d'une structure ??

Merci d'avance :)

Code:

1
2
3
4
5
6
7
8
9
10
typedef struct 
{
    int i;
} structToto;
 
structToto* fonctiontoto()
{
   [...]
    return &sToto; //la variable est de type structToto
}

Hope it helps.

10/05/2006, 19h05
insomniak

Je pense que ça ira, merci :D
10/05/2006, 19h19
insomniak
Et mince... Petit problème...

En fait, ma structure est déja déclarée dans ma classe, et c'est un pointeur car je fais une allocation dynamique pendant le programme. Ainsi, ma fonction doit retourner l'adresse d'une partie du tableau de structure en question.

Comment faire ?
Code:

1 2 3 4 struct Data_Texture_Sol C_Terrain::*Get_DataTextureSol(int TextureSol) { return &Data_TextureSol[TextureSol]; }
Code:

1 2 3 4 5 6 7 8 9 10 class C_Terrain { private: [...] struct Data_Texture_Sol *Data_TextureSol; public: struct Data_Texture_Sol *Get_DataTextureSol(int TextureSol); };

Si j'ai bien compris, Data_TextureSol est un tableau? Si oui, alors:

Code:

1
2
3
4
5
6
7
8
9
10
 
class C_Terrain
{
private:
[...]
Data_Texture_Sol *Data_TextureSol; //pas de struct en début de ligne
public:
 
Data_Texture_Sol *Get_DataTextureSol(int TextureSol); //pas de struct en début de ligne
};

[/quote]

Code:

1
2
3
4
5
6
7
8
9
10
11
 Data_Texture_Sol* C_Terrain::Get_DataTextureSol(int TextureSol)
{
    if (TextureSol<size) //size=taille de ton tableau
    {
        return &Data_TextureSol[TextureSol];
    }
    else
    {
        return NULL;
    }
}

Ce code devrait fonctionner, mais il est absolument horrible.

Dans une optique purement didactique, je me permet de le corriger un peu:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <vector>
typedef struct 
{
    int toto;
} Data_Texture_Sol;
 
class CTerrain  // Evite de mette des "_" partout, ça rend le code inutilement illisible
{
private:
    [...]
        std::vector<Data_Texture_Sol*> m_DataTextureSolList; //l'utilisation du template vector est infiniment préférable à un tableau de type C
//de plus, utilise de préférence un tableau de pointeurs, c'est plus souple
//enfin, l'utilisation du préfixe "m_" indique qu'il s'agit d'une variable membre. C'est une convention utilisée par beaucoup de développeur.
public:    
    Data_Texture_Sol* GetDataTextureSol(int iIndex); //la pertinence des noms de variables est importante. De plus, le mot "index" représente un concept ultra fréquent en programmation.
};
 
Data_Texture_Sol* CTerrain::Get_DataTextureSol(int iIndex)
{
    if (iIndex<m_DataTextureSolList.size())
    { // toujours tester la validité d'un indice quand on attaque un tableau
        return m_DataTextureSolList.at(iIndex);
    }
    else
    {
        return NULL;
    }
}

10/05/2006, 19h54
Matthieu Brucher

On en fait pas de typedef struct machin {} en C++, le typedef ne sert plus ;)
Je plussoie r0d ;)
10/05/2006, 20h20
insomniak

Merci Rod, là j'ai pas le temps, j'étudierai le code demain. Les vecteurs n'ont-ils pas un résultat en performances plus faibles ?? Prennent-ils plus de ressources ??

Encore merci :)
10/05/2006, 23h41
Matthieu Brucher

Les performances, c'est à laisser pour la phase d'otimisation lorsqu'on a vérifié que le goulot d'étranglement était à ce niveau. Que ce soit pour la consommation CPU ou mémoire. Après profiling.
11/05/2006, 10h04
r0d

Et puis de toutes façon, je pense qu'en général un vector est plus efficace, autant en ce qui concerne les performances que le poids des données. En effet, les conteneurs de la stl sont optimisés à tous les niveaux.
11/05/2006, 17h50
insomniak

Ok, je crois que je vais me mettre à utiliser beaucoups plus souvent les vector.

Par contre, j'ai une petite question... Je comprends pas trop comment tu veux que j'utilise des pointeurs ?

Dans mon programme, j'initialise les structures sans pointeur, et je donne l'adresse de la structure à chacun de mes cases...

Concernant les données membres, si je fais un pointeur vers ces données, j'enlève le m_ dans le nom du pointeur je suppose ? Ou y-a-il un nom spécial pour les pointeurs ?

Je reposterai peut-etre si j'ai d'autres questions... Encore merci :)
11/05/2006, 18h09
r0d

Citation:

Envoyé par insomniak

Ok, je crois que je vais me mettre à utiliser beaucoups plus souvent les vector.

En voilà une bonne résolution :D

Citation:

Envoyé par insomniak

Par contre, j'ai une petite question... Je comprends pas trop comment tu veux que j'utilise des pointeurs ?

Dans mon programme, j'initialise les structures sans pointeur, et je donne l'adresse de la structure à chacun de mes cases...

Je ne comprends pas ton problème :/

Citation:

Envoyé par insomniak

Concernant les données membres, si je fais un pointeur vers ces données, j'enlève le m_ dans le nom du pointeur je suppose ? Ou y-a-il un nom spécial pour les pointeurs ?

le préfixe m_ signifie que la variable appartient à la classe. En c++, on est toujours dans une classe. Les variables que tu déclare dans ta classe (dans le .h) commencerons toutes par m_. Les autres variables (paramètres des méthodes, variables locales, etc.) n'auront pas ce suffixe.
Pour les pointeurs, on utilise p. Par exemple un pointeur sur un objet de type Toto sera déclaré ainsi: Toto* pToto; Et si cette variable est membre de la classe, donc déclarée dans le .h, elle sera notée m_pToto.

Hope it helps.
11/05/2006, 18h18
Matthieu Brucher

Ces histoires de m_ devant les variables, ça vient des tréfonds de la programmation, la notation hongroise, ...
On peut largement s'en passer.
11/05/2006, 18h42
r0d

En effet, je plussoie. En fait, dans cette discussion, j'ai mis l'accent sur cette notation car je voulais exprimer que le nommage est important. Après c'est sût qu'on utilise la convention que l'on souhaite. CErtains utilisent leurs propres conventions. Et s'il y en a certaines que je n'apprécie pas particulièrement (comme le fait de mettre un _ avant, pour les variables membre), l'important est d'en utiliser une. Depuis quelque temps, j'utilise plutôt celle préconisée par Herb Sutter, en mettant des _ après le nom de variable.