Constructeur dans la mise en œuvre et d'en-tête

Le constructeur doit, à ma connaissance, être définis dans le fichier d'implémentation, mais j'ai seulement été en mesure de trouver des exemples avec la classe à l'intérieur d'un fichier principal au lieu de diviser en un .h et .fichier cpp

Tous j'ai besoin de savoir c'est si mon code est séparé d'une manière acceptable..

Entité.h:

    using namespace std;

class cEntity {
private:
    /*-----------------------------
    ----------Init Methods---------
    -----------------------------*/
    int *X, *Y;
    int *Height, *Width;

public:
    /*-----------------------------
    ----------Constructor----------
    -----------------------------*/
    cEntity (int,int, int, int);

    /*-----------------------------
    ----------Destructor-----------
    -----------------------------*/
    ~cEntity ();

    /*-----------------------------
    ----------Set Methods----------
    -----------------------------*/

    /*Set X,Y Methods*/
    void setX(int x){*X=x;};
    void setY(int y){*Y=y;};
    void setXY(int x, int y){*X=x; *Y=y;};

    /*Set Height, Width Methods*/
    void setHeight(int x){*Height=x;};
    void setWidth(int x){*Width=x;};
    void setDimensions(int x, int y){*Height=x; *Width=y;};

    /*-----------------------------
    ----------Get Methods----------
    -----------------------------*/

    /*Get X,Y Methods*/
    int getX(){return *X;};
    int getY(){return *Y;};

    /*Get Height, Width Methods*/
    int getHeight(){return *Height;};
    int getWidth(){return *Width;};
};

et Entity.cpp:

#include "Entity.h"


cEntity::cEntity (int x, int y, int height, int width) {
   X,Y,Height,Width = new int;
  *X = x;
  *Y = y;
  *Height = height;
  *Width = width;
}

cEntity::~cEntity () {
  delete X, Y, Height, Width;
}

Je tiens également à dire merci à tous pour avoir été si utile, surtout sur ma première question!

Je suggère à la recherche en boost.shared_ptr / boost.scoped_ptr. Ils gèrent la suppression de la destruction et de votre risque de fuites de mémoire est plus faible. Aussi, faire le destructeur virtual sauf si vous avez une raison pour ne pas le faire.
Je suggère à la recherche dans le non-types de pointeur.
delete X, Y, Height, Width; ce n'est pas ce que vous pensez que cela fonctionne.
aussi seule la Largeur sera attribué...
Bien, je suppose que vous voulez dire que j'avais besoin d'un autre "supprimer" par variable? Et je vais lire sur la bibliothèque boost et le mot clé virtual.

OriginalL'auteur Nick Savage | 2011-11-11

  1. 3
    cEntity::cEntity (int x, int y, int height, int width) {

    est correct

       X,Y,Height,Width = new int;

    pas tellement. Qui définit Width à une nouvelle int, mais pas le reste. Vous avez probablement prévu:

       X = new int(x);
   Y = new int(y);
   Height = new int(height);
   Width = new int(width);

    Noter que cette méthode de construction ne fonctionnera pas pour les objets sans affectation/copie, comme des références. Pour certains objets, il est aussi plus lent que la construction en place. En tant que tel, le moyen privilégié de construire est comme suit: 

    cEntity::cEntity (int x, int y, int height, int width) {
    :X(new int(x))
    ,Y(new int(y))
    ,Height(new int(height))
    ,Width(new int(width))
{}

    C'est mieux, mais si l'une des exceptions sont levées, vous devez en quelque sorte libérer ceux qui ont été attribués. Mieux, c'est de faire de chacun de ces membres un std::unique_ptr<int>, donc ils vont libérer eux-mêmes et de vous sauver beaucoup de maux de tête.

    Intéressant, merci pour me montrant autres méthodes de construction.. je suis très nouveau à tout cela, mais je suis d'essayer d'apprendre 😛
    Ou de ne pas faire d'eux des pointeurs. Ensuite, l'attribution se fait à l'intérieur de l'objet lui-même et qu'ils seront libérés lors de la cEntity objet est détruit.
    J'ai supposé qu'ils étaient des pointeurs pour une raison, mais vous soulevez un bon point.
    J'ai supprimé tous les pointeurs à partir de cet exemple. Cependant n'est-ce pas dire que je vais être incapable de créer de nouvelles instances de ma classe en temps réel alors que le programme est en cours d'exécution?
    Pas de. Vous pouvez toujours dire new cEntity(); ou quelle que soit la classe dérivée que vous souhaitez sur le tas. Techniquement, même les objets qui vivent sur la pile sont créés "en temps réel" (avec l'exception possible de la non-référence, const objets [voir constexpr en C++11] ou avec globals [alloué au démarrage du programme]).

    OriginalL'auteur Mooing Duck

  2. 3

    Oui, c'est OK.
    Cependant, il y a un problème avec votre constructeur et un destructeur.
    Ce que votre code n'est d'allouer un int et votre destructeur libère un int aussi.
    De toute façon, il n'est pas nécessaire d'utiliser des pointeurs ici.
    Un peu mieux la mise en œuvre (si nous n'avons pas d'utiliser des pointeurs intelligents), pourrait être:

    [L'entité.h]

    private:
    /*Private fields*/
    int X, Y;
    int Height, Width;

    [Entity.cpp]

    cEntity::cEntity (int x, int y, int height, int width) {
  X = x;
  Y = y;
  Height = height;
  Width = width;
}
cEntity::~cEntity () {
}

    Et une chose de plus. Essayez d'éviter de using namespace std; dans vos fichiers d'en-tête. Si vous le faites, vous force à ceux qui comprennent votre en-tête à utiliser cette instruction d'utilisation et il peut provoquer de l'espace de noms des affrontements.

    Alors serait-il préférable de simplement faire usage de "std::" ou est-il une autre façon de l'exclusion de l'espace de noms?
    Nick, vous pouvez le voir, cette question: Pourquoi ne devrais-je pas mettre "using namespace std" dans un en-tête?
    Vous n'avez pas besoin d'accéder à l'espace de noms std dans votre code ici. Et oui, quand vous en avez besoin, vous allez utiliser std::.
    L'espace de noms std EST nécessaire plus loin dans le code, c'est simplement une section que je voulais des informations sur. Plus bas, j'ai utiliser des chaînes et des vecteurs.

    OriginalL'auteur Marek Kurdej

  3. 1

    Votre séparation est très bien. La mise en œuvre de ces fonctions est mal, mais vous vous êtes séparés à partir de la déclaration convenablement. (Ils ne sont pas allouer ou libérer autant d'objets que vous pensez qu'ils font.)

    OriginalL'auteur Rob Kennedy

  4. 0

    Oui. Pour la séparation, au moins, c'est généralement la meilleure façon de le faire.

    Que pour la mise en œuvre effective vous avez quelques questions. Je ne suis pas vraiment sûr de ce que vous essayez de faire avec le constructeur ou si vous avez les bons types de données pour les variables de membre de classe, mais quelque chose semble hors tension.

    Ouais c'est ce que j'ai dit
    droite, droite, ninja edit 🙂

    OriginalL'auteur Pepe

  5. -1

    Toute méthode définie dans la classe est implicitement intégrées, y compris le constructeur.

    I. e. 

    class MyClass  
{  
public:    
    MyClass() {};  
};

    définit un constructeur inline, ce qui peut (ou non) d'améliorer vos performances du code,

    Alors que

    class MyClass  
{  
public:  
    MyClass();  
};  

MyClass::MyClass()
{
};

    n'est pas incorporé, et donc de ne plus avoir ces avantages. Les deux options sont correctes C++.

    Juste mes 2 cents.

    P. S Et oui, lorsque vous décidez de stocker des pointeurs à l'intérieur d'une classe de cette manière, vous ouvrez une boîte de Pandore.

    Serait-il plus sage de simplement sauter à la mise en œuvre de ce scénario et de l'utilisation d'un constructeur inline?
    Dépend. Les Interfaces sont destinés à être court, propre et facile à comprendre. Si il y a beaucoup de code dans le constructeur, il va polluer votre fichier d'interface. Votre de 4 constructeur de lignes est probablement OK à l'intérieur .h bien.
    "Toute méthode définie dans la classe est implicitement inline" n'a vraiment pas de sens. Le compilateur va décider si quelque chose va être incorporé basée sur certaines de mise en œuvre de comportement défini.

    OriginalL'auteur AlexK