L'initialisation d'un objet avec et sans opérateur new

Si j'ai une classe Rectangle

class Rectangle{

private:
    double width;
    double height;


public:
void    Set(double w , double l){
    width   = w;
    height  = l;
}
};

et je decleare un objet tel:

Rectangle *Obj;

et puis essayez d'initialiser ses propriétés:

Obj->Set(3,5);

le compilateur au moment de l'exécution: The variable 'Obj' is being used without being initialized.

Le problème peut être résolu par l':

Rectangle *Obj=new Rectangle;

Je voudrais poser des questions sur la raison! Et pourquoi le compilateur n'affiche pas de message d'erreur à la compilation le temps?

OriginalL'auteur Aan | 2011-11-23

c++memory-management new-operator

23
```
Rectangle *Obj;
```
juste définit un pointeur à un objet de la classe Rectangle. La définition d'un pointeur de ne pas réserver de la mémoire pour l'objet lui-même, juste pour le pointeur. Ainsi, si vous accédez à l'aide du pointeur, vous aurez probablement à une adresse en mémoire qui n'a même pas partie de votre processus. Cependant, le compilateur ne peut pas savoir que vous n'avez pas initialise le pointeur (le mot clé ici est de l'aliasing), et donc ne peut pas sortir un message d'erreur.

La solution est soit à l'aide new comme vous l'avez suggéré, ou de déclarer une instance de Rectangle comme suit:
```
Rectangle Obj;
```
qui va appeler un constructeur par défaut. Vous pouvez ensuite définir vos membres à l'aide de
```
Obj.Set(3, 5);
```
Juste un nit, mais Rectangle* Obj; n'est pas seulement déclarer; définit. Et il ne réserver de la mémoire; de suffisamment de mémoire pour stocker un pointeur.
Vous êtes bien sûr le droit. Je vais mettre à jour ma réponse tout de suite

OriginalL'auteur arne
8
et je decleare un objet tel:
```
Rectangle *Obj;
```
Faux, il déclare une pointeur, pas un objet. Les pointeurs doivent être initialisé soit à l'aide de new ou en leur attribuant l'adresse d'un objet existant.

Un pointeur est un objet, au moins en C++. Ceci définit un objet de type Rectangle*. Non initialisée, bien sûr.

OriginalL'auteur Björn Pollex
4

Mmm un peu de confusion:

le compilateur au moment de l'exécution: La variable 'Obj' est utilisé sans être initialisé

Qu'est ce que vous souhaitez appeler moment de la compilation. Juste redresser le jargon.

Aussi, de la façon la plus simple serait de
```
Rectangle Obj;
Obj.Set(3,5);
```
ce qui est suffisant pour la plupart des scénarios, à l'exception des allocations dynamiques, ou polymorphes conteneurs:
```
std::vector<Shape*> v;
v.push_back(new Rectange());
v.back()->Set(3,5);

v.push_back(new Circle());
v.back()->Set(3,5);

//
```
Bien que lors de l'utilisation des new vous devriez être en se souvenant de delete. Cela peut être tout à fait un cauchemar (à la lumière des exceptions, trop). Je suggère:
```
std::vector<std::shared_ptr<Shape*> > v;
v.push_back(std::make_shared<Rectange>());
v.back()->Set(3,5);

v.push_back(std::make_shared<Circle>());
v.back()->Set(3,5);
```
Ne serait pas le plus simple (et le meilleur) de manière à être: Rectangle Obj = { 3, 5 };. En règle générale, vous ne devriez pas créer des objets non initialisées. (La seule exception peut-être si vous êtes en train de lire en elle, à l'aide de >>, dans l'instruction suivante.)
Obj ne fait pas d'objet non initialisé (au moins je n'assume pas c'est une struct avec pas de constructeur par défaut ET aucun champ initialiseurs. Aussi, j'ai tendance à ne pas jeter de C++11 spécificités des débutants réponses; shared_ptr peut être utilisé à partir de boost, l'initialisation uniforme ne peut pas. (PS width et height sont privés de toute façon)
Il ne avec ses de la mise en œuvre de Rectangle. Et j'avais raté le private; il n'y a aucun moyen de créer une initialisé Rectangle. Il a besoin d'un constructeur, pas un Set fonction.
avec j'approuve sans réserve. C'est aussi un peu hors-sujet pour la question 🙂

OriginalL'auteur sehe
3

Avec Rectangle *Obj;, vous devez déclarer un pointeur vers un Rectangle, mais vous n'avez pas dit Obj à laquelle Rectangle il devrait point. Vous pouvez définir ou instancier Obj plus tard à une Rectangle ou seulement si vous avez besoin d'.

C++ est tout au sujet de vous donner un contrôle précis de votre mémoire et de performances. En fait, c'est pourquoi il est utilisé dans certains environnements embarqués! Automatiquement l'instanciation de Obj pose plusieurs "problèmes"
- Quand sommes-nous libres Obj?
- Qui libère Obj?
- Que dire de la performance des implications de la création d'un Rectangle sur le tas?
- Est-ce un environnement dans lequel nous avons suffisamment de ressources (mémoire, CPU, etc) à même de créer le Rectangle, surtout si elle est grande.
- - Vous passer l'adresse de Obj quelque part et puis instancier au moment de l'exécution par le biais de certains de méthode complexes que nous ne pouvons pas analyser statiquement?
Ce que vous faites n'est pas une erreur de syntaxe, qui est ce que les compilateurs de générer des erreurs-erreurs lors de la compilation. Un analyseur (l'un est intégré à Visual Studio 2010 professional) peut vous avertir que vous êtes en utilisant une variable non initialisée, même si c'est optionnel et vous pouvez avoir besoin de l'activer.

OriginalL'auteur foxy
3

pointeur sans nouveau, c'est dire une chose sans la mémoire ..
SI u ont à utiliser les nouvelles avec le pointeur.
Cependant
Rectangle rect;
va defaultly allouer de la mémoire .

pour le vérifier,
faire d'un constructeur dans la classe Rectangle comme,
```
void Rectangle
{
  cout<<"Rectangle Constructor";
}
```
puis,dans les principales
```
Rectangle *rect; -->>O/P  -- "Nothing"
Rectangle rect2; -->>O/P  -- Rectangle Constructor
rect=new Rectangle; -->>O/P  -- Rectangle Constructor
```
OriginalL'auteur Subhranshu
2

pourquoi le compilateur n'affiche pas de message d'erreur à la compilation de temps?

Parce que, c'est syntaxiquement correct. Cependant, de telles déclarations conduira à comportement indéfini, smart compilateurs toujours émettre un avertissement.

Dans g++, vous pouvez tourner ce genre d'avertissement du compilateur en erreurs.

OriginalL'auteur iammilind
-1

La déclaration rectangle *obj signifie simplement qu'il existe un pointeur qui pointe vers la variable de type rectangle.

Avec cette déclaration, vous êtes juste la création d'un pointeur
pas l'instance de l'objet rectangle
l'utilisation de ce pointeur, vous devez stocker le rectangle variable de type adresse du pointeur

Les deux façons de le faire sont par
```
obj=new rectangle;  //variable is created in the stack storage
```
ou
```
rectangle r;
obj =&r;     //variable is created in the heap storage
```
Je pense qu'il est inversé. l'un avec nouveau est créé sur le tas et le deuxième est dans la pile.

OriginalL'auteur Dark Coder

Vous devez vous connecter pour publier un commentaire.