Typedefs per trasmettere le relazioni tra le classi

Question

Typedefs per trasmettere le relazioni tra le classi

#1 da (5 voti)
#2 da (2 voti)

2

Mi chiedo se il seguente uso di typedef sia una buona pratica o se ci siano degli svantaggi.

Fondamentalmente ho un sacco di "dati" -strutture, che sono destinati ad essere utilizzati in contenitori (globalmente unici), e tengono indici ad altri (globalmente unici) contenitori, il motivo è quello di mantenere l'accesso alla memoria localizzato. Piuttosto che avere i tipi di indice essere generico size_t ho pensato di nominarli come segue per chiarezza:

typdef uint32_t MeshID;

typedef Mat4 Transform;
typedef std::vector<Transform>::size_type TransformIndex;

struct AABB
{
    AABB(const Vec3& center, const Vec3& extent);

    typedef std::vector<ModelMesh>::size_type AABBIndex;


    Vec3 mAABBCenter;
    Vec3 mAABBExtent;
};

struct ModelMesh
{
    ModelMesh(const MeshID meshID, const uint32_t aabbIndex, const uint32_t transformIndex);

    typedef std::vector<ModelMesh>::size_type ModelMeshIndex;


    const MeshID mMeshID;

    const AABB::AABBIndex mAABBIndex;
    const TransformIndex mTransformIndex;
};

struct ModelNode
{
    ModelNode(const uint32_t aabbIndex, const uint32_t transformIndex);

    typedef std::vector<ModelNode>::size_type ModelNodeIndex;


    const ModelNodeIndex mNodeStartIndex;
    const ModelNodeIndex mNodeEndIndex;

    const ModelMesh::ModelMeshIndex mMeshStartIndex;
    const ModelMesh::ModelMeshIndex mMeshEndIndex;

    const AABB::AABBIndex mAABBIndex;
    const TransformIndex mTransformIndex;
};

struct Model
{
    Model(const std::string& name, const Mat4& initialTransform, const Vec3& minBounds, const Vec3& maxBounds, const MeshID meshID, MaterialPtr material);
    Model(DX11Renderer& renderer, const JonsPackagePtr jonsPkg, const PackageModel& pkgModel, LoadMaterialFunc loadMaterialFunction);
    ~Model();

    bool operator==(const Model& m);
    bool operator==(const std::string& modelName);


    const std::string mName;
    const size_t mHashedID;

    const ModelNode::ModelNodeIndex mRootNodeIndex;
};

La motivazione è tale che la relazione tra le strutture sia chiara. Il rovescio della medaglia è forse un sacco di definizioni? Troppo chiacchierone?

Nel complesso, questa è una buona pratica?

design c++ coding-standards

posta KaiserJohaan 19.02.2015 - 22:45

fonte

2 risposte

2

In generale, l'uso di un typedef non è mai veramente una brutta cosa, tutto ciò che dice è dire al compilatore che quando usi, diciamo "Trasforma", in realtà intendevi "Mat4". Tutto il typedef fa è più facile per il programmatore specificare tra tipi separati. Di solito non c'è nessun svantaggio nell'usare typedef.

Nel complesso, non è né una buona né una cattiva pratica. Assicurati solo di ricordare che cosa significa ogni typedef.

risposta data 19.02.2015 - 23:23

fonte

Leggi altre domande sui tag design c++ coding-standards

Aggiunta del supporto per svn al nostro repository git Accesso a un sistema sensibile alla latenza

score 5 · Accepted Answer

Il cuore della creazione di astrazioni è di dare alle cose un buon nome, il che rende chiaro ciò che rappresenta un tipo di dati specifico. E questo è quello che stai facendo qui, non meno, non di più.

Creare le astrazioni giuste è ciò che rende effettivamente la differenza tra codice buono e codice errato, quindi sì, si presume che queste astrazioni ti servano bene, questa è una buona pratica.