initialiser struct contenir des références à des structs

Est-il possible d'avoir une structure contenant des références à des structures. Et comment sont-ils initialisé? Voir petit exemple ci-dessous.

Grâce

typedef struct {
  int a;
}typeInner1;


typedef struct {
  int b;
}typeInner2;


typedef struct {
  typeInner1 &one;
  typeInner2 &two;
}typeOuter;

void fun2(typeOuter *p){
  p->one.a =2;
  p->two.b =3;
}


void fun(typeInner1 &arg1,typeInner2 &arg2){
  typeOuter *ptr = new typeOuter;//<-- how to write initializer
  fun2(ptr);
}


int main(){
  typeInner1 arg1;
  typeInner2 arg2;
  fun(arg1,arg2);

  //now arg1.a should be 2 and arg2.a=3
}

Ok merci pour tous les commentaires. J'ai également eu à modifier la définition de type de l'typeOuter pour le faire fonctionner. Travail plein de code ci-dessous pour d'autres personnes à trouver ce post.

#include <cstdio>
typedef struct {
  int a;
}typeInner1;


typedef struct {
  int b;
}typeInner2;


typedef struct typeOuter_t {
  typeInner1 &one;
  typeInner2 &two;
  typeOuter_t(typeInner1 &a1, typeInner2 &a2) : one(a1), two(a2) {}
}typeOuter;

void fun2(typeOuter *p){
  p->one.a =2;
  p->two.b =3;
}


void fun(typeInner1 &arg1,typeInner2 &arg2){
  typeOuter *ptr = new typeOuter(arg1,arg2);
  fun2(ptr);
}


int main(){
  typeInner1 arg1;
  typeInner2 arg2;
  fun(arg1,arg2);

  //now arg1.a shoule be 1 and arg2.a=3
  fprintf(stderr,"arg1=%d arg2=%d\n",arg1.a,arg2.b);
}
BTW, typedef struct {...} foo; n'est pas "idiomatiques" en C++, il suffit de la rédaction struct foo {...}; est plus habituel (et ne vous permettent d'utiliser foo comme un nom de type directement).

OriginalL'auteur monkeyking | 2013-02-09

  1. 3

    Donner typeOuter un constructeur approprié:

    struct typeOuter
{
  typeInner1 &one;
  typeInner2 &two;
  typeOuter(typeInner1 &a1, typeInner2 &a2) : one(a1), two(a2) {}
};



void fun(typeInner1 &arg1, typeInner2 &arg2) {
  typeOuter *ptr = new typeOuter(arg1, arg2);
  fun2(ptr);
}

    OriginalL'auteur Angew

  2. 3

    Avant C++11, vous aurez besoin d'un constructeur pour votre struct typeOuter, et initialiser les références à des membres de la liste d'initialiseur:

    typeOuter(typeInner1& i1, typeInner2& i2) : one(i1), two(i2) {}

    Avec C++11 vous avez également la possibilité d'utiliser une liste d'initialiseur directement (sans passer par la définition d'un constructeur vous-même):

    typeOuter *ptr = new typeOuter { arg1, arg2 };

    OriginalL'auteur Mat

  3. 2

    En C++, vous pouvez créer un constructeur pour votre struct. Les structures sont essentiellement des classes avec public en tant que par défaut modificateur d'accès.

    struct Example
{
    //struct fields..

    Example(); //initialize struct objects.
    ~Example(); //perform clean up if necessary.
};

    OriginalL'auteur Tomislav Dyulgerov

  4. 1

    Votre problème n'est pas d'avoir des références à structs, mais avec l'initialisation de références en général. Les références ne peuvent pas être par défaut-initialisé, peu importe si ce sont des références à un struct ou à un type.

    int& x; //ERROR! Non-initialized reference to int
C& y; //ERROR! Non-initialized reference to a struct C
int z;
C w;
int& a = z; //OK: Initialized reference to int
C& b = w; //OK: Initialized reference to struct C

    Lors de vos références sont variables membres d'une struct, d'autre part (n'importe quel type ils font référence), ils doivent être tenus, dès que votre struct est construit (en tant que références). Par défaut-de la construction de votre struct puis en liant les références n'est pas une option, car elle se fait en deux étapes, et les références qui seraient non initialisée lors de la première étape.

    Par conséquent, vous devez fournir un constructeur pour votre struct et initialiser vos références:

    struct typeOuter {
  typeOuter(typeInner1& o, typeInner2& t) : one(o), two(t) { }
  typeInner1 &one;
  typeInner2 &two;
};

    Votre fun() fonction ressemblerait alors à ceci:

    void fun(typeInner1 &arg1,typeInner2 &arg2){
    typeOuter *ptr = new typeOuter(arg1, arg2);
    fun2(ptr);
}

    OriginalL'auteur Andy Prowl

  5. 1

    Vous pouvez ajouter un constructeur, mais vous pouvez également utiliser l'ensemble de l'initialisation avec une fonction de fabrication. Cela fonctionne dans toutes les versions de C++:

    struct A
{
   int& i;
};

A make_a(int& i)
{
   A a = {i};
   return a;
}

int main()
{
   int i = 0;
   A* a = new A(make_a(i));
}

    OriginalL'auteur dalle

  6. 0

    Uhm..

    #include <cstdio>

struct typeInner1
{
    typeInner1(int a = 0) : m_a(a) {} //typeInner1 constructor
    int m_a;
};

struct typeInner2
{
    typeInner2(int b = 0) : m_b(b) {} //typeInner2 constructor
    int m_b;
};

struct typeOuter
{
    typeOuter(typeInner1& one, typeInner2& two) : m_one(one), m_two(two) {} //typeOuter constructor

    typeOuter& set(int a, int b) { m_one.m_a = a; m_two.m_b = b; return *this; }
    typeOuter& print() { printf("typeInner1 a is %i and typeInner2 b is %i\n", m_one.m_a, m_two.m_b); return *this; }

    typeInner1& m_one;
    typeInner2& m_two;
};

typeOuter fun(typeInner1& arg1, typeInner2& arg2)
{
    return typeOuter(arg1, arg2);
}

int main()
{
  typeInner1 arg1;
  typeInner2 arg2;

  fun(arg1, arg2).print().set(101, 202).print().set(202, 303).print();

  return 0;
}

    Sorties

    typeInner1 a is 0 and typeInner2 b is 0
typeInner1 a is 101 and typeInner2 b is 202
typeInner1 a is 202 and typeInner2 b is 303

    OriginalL'auteur Edward A