J'ai plusieurs classes d'ingénieurs que j'utilise et elles ont les mêmes structures nommées dans les classes. De cela, j'obtiens l'erreur "redéfinition de type 'struct'". Comment puis-je contourner cela?

Exemple:

// Eng1Class.h
#pragma once

struct Eng1And2SameName
{
    unsigned int bottle;
};

class Eng1Class
{
public:
    Eng1Class();
    ~Eng1Class();
};

.

// Eng2Class.h
#pragma once

struct Eng1And2SameName
{
    float x, y;
};

class Eng2Class
{
public:
    Eng2Class();
    ~Eng2Class();
};

.

// Main Program
#include "stdafx.h"
#include "Eng1Class.h"
#include "Eng2Class.h"

int _tmain(int argc, _TCHAR* argv[])
{
    return 0;
}

Erreur: erreur C2011: 'Eng1And2SameName': redéfinition du type 'struct'

Selon ce Erreur de compilation "type 'struct' redéfinition "bien que ce soit la première définition pour cela le #pragma une fois devrait résoudre les problèmes, mais je vois toujours l'erreur. Des informations que vous pouvez fournir?

0
Brad B. 10 août 2017 à 20:22

2 réponses

Définir un espace de noms aiderait

Par exemple, comme vous l'avez dit, erreur avec la même définition de structure dans la même portée de nom. Erreur de rapports entrez la description de l'image ici

Vous pouvez le faire en définissant un espace de noms

#include<iostream>
using namespace std;

namespace Eng1 {
    struct Eng1And2SameName
    {
        unsigned int bottle;

    };
}

namespace Eng2
{

    struct Eng1And2SameName
    {
        float x, y;
    };
}

int main()
{
    Eng1::Eng1And2SameName a;
    Eng2::Eng1And2SameName b;

    return 0;
}
0
Hariom Singh 10 août 2017 à 17:33

Habituellement, les ingénieurs travaillant sur le même produit sont coordonnés d'une manière ou d'une autre, au moins ils utiliseront un référentiel de code source commun et une version commune. Par conséquent, les conflits auraient dû survenir plus tôt.

Des ingénieurs «non coordonnés» peuvent se produire lorsqu'ils travaillent sur différents produits, et si tel est le cas, chaque produit peut avoir son propre espace de noms. Ainsi, vous pouvez combiner les produits sans avoir de conflits:

// in a header:
namespace Eng1Class {

    struct Eng1And2SameName
    {
        unsigned int bottle;
    };

    class EngClass
    {
    public:
        EngClass();
        ~EngClass();
    };

}

// in the cpp-file
Eng1Class::EngClass::EngClass() {
    cout << "hello, Class 1";
}

// in another (or even the same) header
namespace Eng2Class {

    struct Eng1And2SameName
    {
        float x, y;
    };

    class EngClass
    {
    public:
        EngClass();
        ~EngClass();
    };
}

// in another (or even the same) cpp-file
Eng2Class::EngClass::EngClass() {
    cout << "hello, Class 2";
}
0
Stephan Lechner 10 août 2017 à 17:38