2017-10-20 3 views
1

Je me demande si quelqu'un a une solution au problème suivant, j'ai deux structures presque identiques, et je dois passer les valeurs de la structure A à la structure B et elles ont une différence d'un membre.Passer des valeurs de membre entre des structures presque identiques

exemple ressemble à quelque chose comme ce que j'ai ces struct:

struct insideA 
{ 
double C1; 
double C2; 
int C3; 
str C4; 
}; 

struct insideB 
{ 
int D3; 
str D4; 
}; 

struct A 
{ 
insideA inA; 
double c; 
std::string d; 
} a; 

struct B 
{ 
insideB inB; 
double c; 
std::string d; 
} b; 

Maintenant que le struct A et B sont presque similaires, mais pas exactement et si l'on imagine que le b est peuplé, je peux facilement passer la valeurs membre par membre followingly:

a.inA.C3 = b.inB.D3; 
a.inA.C4 = b.inB.D4; 
a.c = b.c; 
a.d = b.d; 

et maintenant a toutes les informations que b avait et je peux remplir les autres membres d'un. Donc, mon problème est que je dois le faire environ 30 ou 40 fois avec des structures différentes, où seul le premier membre de la structure change, donc il y a une meilleure méthode pour faire cela que de passer les valeurs b individuellement?

+0

créer une classe de base contenant les mêmes membres et implémenter la copie. "Presque identique" ne vous aidera pas beaucoup – user463035818

+1

pouvez-vous modifier les définitions de structure existantes? – nate

+0

Non, je ne peux pas éditer la structure existante, car il est dans un pilote et je ne peux pas accéder au code source :( – Pedro

Répondre

1

Utilisons des modèles!

template <struct Inside> 
struct AorB 
{ 
    Inside in; 
    double c; 
    std::string d; 

    template <struct OtherInside> 
    AorB& operator=(const AorB<OtherInside>& that) { 
    in = that.in; 
    c = that.c; 
    d = that.d; 
    } 
}; 

struct A : AorB<insideA> 
{ 
    template <struct OtherInside> 
    A& operator=(const AorB<OtherInside>& that) { 
    AorB<insideA>::operator=(that); 
    return *this; 
    } 
}; 

struct B : AorB<insideB> 
{ 
    template <struct OtherInside> 
    B& operator=(const AorB<OtherInside>& that) { 
    AorB<insideB>::operator=(that); 
    return *this; 
    } 
}; 

Vous pouvez également étendre cette idée aux classes internes.

+0

Hey, merci de votre réponse rapide, j'ai essayé de décrire soigneusement mon problème, mais j'ai oublié de clarifier que, entre toutes les différentes structs que je dois passer, chacun des membres du «corps» est différent, donc avec cette méthode, je devrais faire le besoin de faire une solution similaire pour chacun d'entre eux, puis voir quel modèle utiliser dans ce cas, je pensais qu'il y avait un moyen d'automatiser en quelque sorte – Pedro