Pourquoi devrais-je utiliser un pointeur plutôt que l'objet lui-même?

Il est très malheureux que vous voyez à l'allocation dynamique si souvent. Cela montre juste combien de mauvais programmeurs C++ il y a des.

Dans un sens, vous avez deux questions enfermé dans une. La première, c'est quand doit-on utiliser l'allocation dynamique (à l'aide de new)? Le deuxième est quand devrions-nous utiliser des pointeurs?

L'important à retenir est que vous devez toujours utiliser le bon outil pour le travail. Dans presque toutes les situations, il y a quelque chose de plus approprié et plus sûr que d'effectuer manuel de l'allocation dynamique et/ou utilisant des pointeurs.

Allocation dynamique

Dans votre question, vous avez fait deux façons de créer un objet. La principale différence est la durée de conservation de l'objet. Lorsque vous faites Object myObject; au sein d'un bloc, l'objet est créé avec automatique de la durée de stockage, ce qui signifie qu'il sera automatiquement détruite quand elle est hors de portée. Lorsque vous ne new Object(), l'objet est dynamique, durée de stockage, ce qui signifie qu'il reste en vie jusqu'à ce que vous avez explicitement delete il. Vous devriez uniquement utiliser la dynamique de la durée de stockage lorsque vous en avez besoin.
C'est, vous devriez toujours préfèrent la création d'objets automatique de la durée de stockage lorsque vous pouvez.

Les deux principales situations dans lesquelles vous pourriez avoir besoin d'allocation dynamique:

1. Vous besoin de l'objet à survivre à la portée actuelle - cet objet spécifique à l'emplacement mémoire spécifique, pas une copie. Si vous êtes d'accord avec la copie/déplacement de l'objet (la plupart du temps, vous devriez être), vous devez préférer une automatique des objets.
2. Vous avez besoin d'allouer beaucoup de mémoire, qui peut facilement remplir la pile. Ce serait bien si nous n'avions pas à nous préoccuper de ce (la plupart du temps, vous ne devriez pas le faire), car il est vraiment en dehors du champ de C++, mais malheureusement, nous avons à traiter avec la réalité des systèmes que nous développons pour.

Lorsque vous avez absolument besoin de l'allocation dynamique, vous devez l'encapsuler dans un pointeur intelligent ou d'un autre type qui effectue RAII (comme la norme de conteneurs). Des pointeurs intelligents de fournir la propriété sémantique des objets alloués dynamiquement. Jetez un oeil à std::unique_ptr et std::shared_ptr, par exemple. Si vous les utilisez correctement, vous pouvez presque entièrement d'éviter d'effectuer votre propre gestion de la mémoire (voir la La règle de Zéro).

Pointeurs

Cependant, il existe d'autres utilisations générales pour les matières premières, les pointeurs au-delà de l'allocation dynamique, mais la plupart ont des solutions de rechange que vous préférez. Comme avant, toujours préférer les alternatives à moins que vous vraiment besoin de pointeurs.

1. Vous avez besoin de référence sémantique. Parfois, vous voulez passer un objet à l'aide d'un pointeur (indépendamment de la façon dont il a été affecté) parce que vous voulez que la fonction à laquelle vous êtes de passage qu'il ait accès que l'objet (pas une copie). Cependant, dans la plupart des situations, vous devriez préférer les types de référence pour les pointeurs, parce que c'est précisément ce qu'ils sont conçus pour. Remarque ce n'est pas nécessairement sur l'extension de la durée de vie de l'objet au-delà de la portée actuelle, comme dans le cas 1 ci-dessus. Comme avant, si vous êtes d'accord avec le passage d'une copie de l'objet, vous n'avez pas besoin de référence sémantique.

2. Vous avez besoin de polymorphisme. Vous ne pouvez appeler des fonctions polymorphically (qui est, selon le type dynamique d'un objet) par l'intermédiaire d'un pointeur ou d'une référence à l'objet. Si c'est le comportement que vous avez besoin, alors vous avez besoin d'utiliser des pointeurs ou des références. De nouveau, les références devraient être privilégiées.

3. Vous voulez représenter qu'un objet est en option en permettant à un nullptr être passé quand l'objet est omis. Si c'est un argument, vous devez vous préférez utiliser des arguments par défaut ou de la fonction des surcharges. Sinon, utiliser de préférence un type qui encapsule ce comportement, tel que std::optional (introduit en C++17 - avec les anciennes normes C++, l'utilisation boost::optional).

4. Vous souhaitez dissocier les unités de compilation pour améliorer le temps de compilation. La propriété intéressante d'un pointeur, c'est que vous avez seulement besoin d'une déclaration anticipée de la pointe-type (en fait d'utiliser l'objet, vous aurez besoin d'une définition). Cela vous permet de découpler les parties de votre processus de compilation, ce qui peut améliorer de façon significative le temps de compilation. Voir la Pimpl idiome.

5. Vous avez besoin pour l'interface avec une bibliothèque C ou un C-bibliothèque de styles. À ce stade, vous êtes obligé d'utiliser des pointeurs. La meilleure chose que vous pouvez faire est de vous assurer que vous laissez vos premières pointeurs lâche au dernier moment possible. Vous pouvez obtenir un pointeur brut à partir d'un pointeur intelligent, par exemple, à l'aide de son get de la fonction membre. Si une bibliothèque effectue une allocation pour vous qu'elle attend de vous libérer par l'intermédiaire d'une poignée, vous pouvez souvent envelopper la poignée vers le haut dans un pointeur intelligent avec un custom deleter, qui permettra de libérer l'objet de façon appropriée.

Il ya beaucoup d'excellentes réponses à cette question, y compris l'utilisation importante des cas de déclarations, polymorphisme, etc. mais j'ai le sentiment de faire partie de "l'âme" de votre question n'est pas de réponse - à savoir que les différentes syntaxes moyenne pour Java et C++.

Examinons la situation en comparant les deux langues:

Java:

Object object1 = new Object(); //A new object is allocated by Java
Object object2 = new Object(); //Another new object is allocated by Java

object1 = object2; 
//object1 now points to the object originally allocated for object2
//The object originally allocated for object1 is now "dead" - nothing points to it, so it
//will be reclaimed by the Garbage Collector.
//If either object1 or object2 is changed, the change will be reflected to the other

L'équivalent le plus proche, est:

C++:

Object * object1 = new Object(); //A new object is allocated on the heap
Object * object2 = new Object(); //Another new object is allocated on the heap
delete object1;
//Since C++ does not have a garbage collector, if we don't do that, the next line would 
//cause a "memory leak", i.e. a piece of claimed memory that the app cannot use 
//and that we have no way to reclaim...

object1 = object2; //Same as Java, object1 points to object2.

Nous allons voir la variante C++ façon:

Object object1; //A new object is allocated on the STACK
Object object2; //Another new object is allocated on the STACK
object1 = object2;//!!!! This is different! The CONTENTS of object2 are COPIED onto object1,
//using the "copy assignment operator", the definition of operator =.
//But, the two objects are still different. Change one, the other remains unchanged.
//Also, the objects get automatically destroyed once the function returns...

La meilleure façon de penser, c'est que-plus ou moins-Java (implicitement) manipule des pointeurs vers des objets, tandis que le C++ peut traiter des pointeurs vers les objets ou les objets eux-mêmes.
Il y a des exceptions à cela, par exemple, si vous déclarez Java "primitive" types, ils sont des valeurs réelles qui sont copiés, et pas des pointeurs.
Donc,

Java:

int object1; //An integer is allocated on the stack.
int object2; //Another integer is allocated on the stack.
object1 = object2; //The value of object2 is copied to object1.

Cela dit, en utilisant les pointeurs n'est PAS nécessairement ce soit la bonne ou la mauvaise façon de traiter les choses; toutefois, d'autres réponses ont couvert que d'une manière satisfaisante. L'idée générale est que, en C++, vous avez beaucoup plus de contrôle sur la durée de vie des objets, et l'endroit où ils vivent.

La maison, la Object * object = new Object() construire est en fait ce qui est le plus proche de typique Java (ou C#) à la sémantique.

Préface

Java n'est rien comme C++, contrairement à l'exagération. La Java hype machine aimerais que vous croyez que, parce que Java, C++, comme la syntaxe, que les langues sont similaires. Rien ne peut être plus éloigné de la vérité. Cette désinformation est une partie de la raison pourquoi des programmeurs Java aller au C++ et à l'utilisation de Java syntaxe sans en comprendre les implications de leur code.

À partir nous allons

Mais je ne peux pas comprendre pourquoi devrions-nous faire de cette façon. Je suppose qu'il s'
a à voir avec l'efficacité et la rapidité puisque nous obtenir un accès direct à la
adresse de la mémoire. Suis-je le droit?

Le contraire, en fait. Le tas est beaucoup plus lent de la pile, parce que la pile est très simple par rapport au tas. Stockage automatique des variables (aka pile variables) ont leurs destructeurs appelé une fois qu'elles sont hors de portée. Par exemple:

{
    std::string s;
}
//s is destroyed here

D'autre part, si vous utilisez un pointeur alloué dynamiquement, son destructeur doit être appelé manuellement. delete appelle cette destructeur pour vous.

{
    std::string* s = new std::string;
}
delete s; //destructor called

Cela n'a rien à voir avec la new syntaxe répandue en C# et Java. Ils sont utilisés pour des objectifs complètement différents.

Avantages de l'allocation dynamique

1. Vous n'avez pas à connaître la taille du tableau à l'avance

L'un des premiers problèmes que de nombreux programmeurs C++ est que quand ils sont accepter l'arbitraire d'entrée des utilisateurs, vous ne pouvez allouer une taille fixe pour une pile de variable. Vous ne pouvez pas modifier la taille des tableaux soit. Par exemple:

char buffer[100];
std::cin >> buffer;
//bad input = buffer overflow

Bien sûr, si vous avez utilisé un std::string au lieu de cela, std::string interne de la redimensionne, de sorte que ne devrait pas être un problème. Mais essentiellement, la solution à ce problème est l'allocation dynamique. Vous pouvez allouer de la mémoire dynamique basé sur l'entrée de l'utilisateur, par exemple:

int * pointer;
std::cout << "How many items do you need?";
std::cin >> n;
pointer = new int[n];

note: Une erreur que beaucoup de débutants font l'utilisation de l'
la longueur variable des tableaux. C'est une extension GNU et aussi on dans Clang
parce qu'ils reflètent bon nombre des extensions de GCC. Donc la suite
int arr[n] ne doit pas être invoqué.

Parce que le tas est beaucoup plus grand que la pile, on peut arbitrairement allouer/réaffecter autant de mémoire qu'il/elle a besoin, alors que la pile a une limitation.

2. Les tableaux ne sont pas des pointeurs

Comment est-ce un avantage, demandez-vous? La réponse sera devenu clair une fois que vous comprenez la confusion/mythe derrière les tableaux et les pointeurs. Il est communément admis que ce sont les mêmes, mais ils ne le sont pas. Ce mythe vient du fait que les pointeurs peuvent être indicée comme des tableaux et à cause de matrices de décomposition de pointeurs au plus haut niveau dans une déclaration de fonction. Cependant, une fois qu'un tableau se désintègre à un pointeur, le pointeur perd son sizeof de l'information. Donc sizeof(pointer) donnera la taille du pointeur de la souris en octets, qui est généralement de 8 octets sur un système 64 bits.

Vous ne pouvez pas attribuer à des tableaux, seuls les initialiser. Par exemple:

int arr[5] = {1, 2, 3, 4, 5}; //initialization 
int arr[] = {1, 2, 3, 4, 5}; //The standard dictates that the size of the array
                             //be given by the amount of members in the initializer  
arr = { 1, 2, 3, 4, 5 }; //ERROR

D'autre part, vous pouvez faire ce que vous voulez avec des pointeurs. Malheureusement, parce que la distinction entre les pointeurs et les tableaux sont de la main-onde, en Java et en C#, les débutants ne comprennent pas la différence.

3. Polymorphisme

Java et C# ont des équipements qui vous permettent de traiter les objets comme un autre, par exemple à l'aide de la as mot-clé. Donc, si quelqu'un voulait traiter une Entity objet comme un Player objet, que l'on pourrait faire Player player = Entity as Player; Ceci est très utile si vous avez l'intention d'appeler des fonctions en un ensemble homogène conteneur qui ne devrait s'appliquer qu'à un type spécifique. La fonctionnalité peut être réalisée d'une manière similaire ci-dessous:

std::vector<Base*> vector;
vector.push_back(&square);
vector.push_back(&triangle);
for (auto& e : vector)
{
     auto test = dynamic_cast<Triangle*>(e); //I only care about triangles
     if (!test) //not a triangle
        e.GenericFunction();
     else
        e.TriangleOnlyMagic();
}

Donc, dire si uniquement des Triangles a une fonction de Rotation, ce serait une erreur de compilation si vous avez essayé de l'appeler sur tous les objets de la classe. À l'aide de dynamic_cast, vous pouvez simuler le as mot-clé. Pour être clair, si une conversion échoue, elle renvoie un pointeur non valide. Donc !test est essentiellement une abréviation pour vérifier si test est NULL ou un pointeur non valide, ce qui signifie que le cast a échoué.

Avantages de variables automatiques

Après avoir vu toutes les grandes choses de l'allocation dynamique peut le faire, vous vous demandez probablement pourquoi pas à quiconque de ne PAS utiliser l'allocation dynamique de tous les temps? Je l'ai déjà dit-vous une raison, le tas est lente. Et si vous n'avez pas besoin de tout ça de mémoire, il ne faut pas en abuser. Donc, ici, sont quelques-uns des inconvénients dans aucun ordre particulier:

• Elle est sujette à erreur. Manuel de l'allocation de mémoire est dangereux et vous êtes sujet à des fuites. Si vous n'êtes pas compétent dans l'utilisation du débogueur ou valgrind (une fuite de mémoire de l'outil), vous pouvez garder vos cheveux de votre tête. Heureusement RAII les idiomes et les pointeurs intelligents de l'alléger un peu, mais vous devez vous familiariser avec des pratiques telles que La Règle De Trois et La Règle Des Cinq. Il y a beaucoup d'informations à assimiler, et les débutants qui ne savent pas ou ne se soucient pas tomber dans ce piège.

• Il n'est pas nécessaire. Contrairement à Java et C#, où il est idiomatiques pour utiliser le new mot-clé partout, en C++, vous devez utiliser uniquement si vous en avez besoin. La commune de la phrase va, tout ressemble à un clou si vous avez un coup de marteau. Tandis que les débutants qui commencent par C++ ont peur de pointeurs et d'apprendre à utiliser des variables de pile par l'habitude, Java et C#, programmeurs démarrer en utilisant des pointeurs sans le comprendre! C'est littéralement entrer sur le mauvais pied. Vous devez abandonner tout ce que vous savez parce que la syntaxe est une chose, l'apprentissage de la langue en est une autre.

1. (N)RVO - Aka, (Nommé) de la Valeur de Retour d'Optimisation

Une optimisation de nombreux compilateurs faire sont des choses que l'on appelle élision et valeur de retour d'optimisation. Ces choses peuvent éviter d'inutiles copys ce qui est utile pour les objets qui sont très grandes, comme un vecteur contenant de nombreux éléments. Normalement, la pratique courante est d'utiliser des pointeurs pour transfert de propriété plutôt que de copier les grands objets de déplacer autour de lui. Ceci a conduit à la création de déplacer la sémantique et pointeurs intelligents.

Si vous êtes en utilisant des pointeurs, (N)RVO n' PAS se produire. Il est plus avantageux et moins sujettes à l'erreur de prendre avantage de (N)RVO plutôt que de retourner ou de passer des pointeurs si vous êtes inquiet au sujet de l'optimisation. Erreur des fuites peuvent se produire si l'appelant d'une fonction est responsable de l' deleteing un objet alloué dynamiquement, par exemple. Il peut être difficile de suivre la possession d'un objet si les pointeurs sont passés comme une patate chaude. Juste l'utilisation de la pile des variables car il est plus simple et mieux.

En C++, les objets alloués sur la pile (à l'aide Object object; instruction dans un bloc) ne vivent dans le champ d'application qu'elles sont déclarées dans. Lorsque le bloc de code à la fin de l'exécution, l'objet déclarés sont détruits.
Alors que si vous allouer de la mémoire sur le tas, à l'aide de Object* obj = new Object(), ils continuent à vivre dans le tas jusqu'à ce que vous appelez delete obj.

Je voudrais créer un objet sur le tas quand je veux utiliser l'objet non seulement dans le bloc de code qui déclarés/été alloué.

Techniquement, c'est un problème d'allocation de mémoire, cependant, ici, sont deux aspects plus pratiques de la ce.
Il a à faire à deux choses:
1) Champ d'application, lorsque vous définissez un objet sans pointeur, vous ne pourrez plus accéder après le bloc de code il est défini, alors que si vous définissez un pointeur avec les "nouvelles", alors vous pouvez y accéder à partir de n'importe où vous avez un pointeur vers cette mémoire jusqu'à ce que vous appelez "supprimer" sur le même pointeur.
2) Si vous voulez passer des arguments à une fonction que vous souhaitez passer un pointeur ou une référence dans le but d'être plus efficace. Lorsque vous transmettez un Objet puis l'objet est copié, si c'est un objet qui utilise beaucoup de mémoire ce pourrait être la consommation PROCESSEUR (par exemple, la copie d'un vecteur plein de données). Lorsque vous passez un pointeur tous les vous pass est un int (en fonction de la mise en œuvre, mais la plupart d'entre eux sont un int).

Autres que ce que vous avez besoin de comprendre que la "nouvelle" alloue de la mémoire sur le tas qui doit être libéré à un certain point. Lorsque vous n'avez pas à utiliser "nouveaux", je vous suggère d'utiliser un objet définition de "sur la pile".

Disons que vous avez class A qui contiennent class B Lorsque vous souhaitez appeler une fonction de class B à l'extérieur class A vous simplement obtenir un pointeur vers cette classe et vous pouvez faire ce que vous voulez et il sera également modifier le contexte de class B dans votre class A

Mais être prudent avec les objets dynamiques

Ce qui a été discuté lors de la longueur, mais en Java tout est un pointeur. Il ne fait pas de distinction entre la pile et le tas allocations (tous les objets sont alloués sur le tas), de sorte que vous ne réalisez pas que vous êtes en utilisant les pointeurs. En C++, vous pouvez mélanger les deux, en fonction de vos exigences de mémoire. Les performances et l'utilisation de la mémoire est plus déterministe en C++ (duh).

Un pointeur directement référence à l'emplacement de la mémoire d'un objet. Java n'a rien de ce genre. Java a des références qui font référence à la localisation de l'objet par le biais de tables de hachage. Vous ne pouvez rien faire, comme l'arithmétique des pointeurs en Java avec ces références.

Pour répondre à votre question, c'est juste votre préférence. Je préfère utiliser le Java syntaxe.

L'une des raisons pour l'utilisation des pointeurs est à l'interface avec les fonctions C. Une autre raison est d'économiser de la mémoire; par exemple: au lieu de passer d'un objet qui contient beaucoup de données et d'un processeur constructeur par copie d'une fonction, il suffit de passer un pointeur vers l'objet, d'économiser la mémoire et de la vitesse, surtout si vous êtes dans une boucle, mais une référence serait mieux dans ce cas, sauf si vous utilisez un C-gamme de style.

Je vais inclure un important cas d'utilisation de pointeur. Lorsque vous stockez un objet de la classe de base, mais il pourrait être polymorphe.

Class Base1 {
};

Class Derived1 : public Base1 {
};


Class Base2 {
  Base *bObj;
  virtual void createMemerObects() = 0;
};

Class Derived2 {
  virtual void createMemerObects() {
    bObj = new Derived1();
  }
};

Dans ce cas, vous ne pouvez pas déclarer bObj comme un objet direct, vous devez avoir pointeur.

Il existe de nombreuses excellentes réponses déjà, mais laissez-moi vous donner un exemple:

J'ai un Élément simple classe:

 class Item
    {
    public: 
      std::string name;
      int weight;
      int price;
    };

- Je faire un vecteur de tenir un tas d'entre eux.

std::vector<Item> inventory;

J'ai créer un million d'objets d'éléments, et de le repousser sur le vecteur. Je trie le vecteur par nom, puis faire un simple itératif de recherche binaire pour un particulier du nom de l'élément. J'ai tester le programme, et il faut plus de 8 minutes pour terminer l'exécution. Puis-je changer mon inventaire vecteur de la sorte:

std::vector<Item *> inventory;

...et de créer mon millions d'objets d'éléments par le biais des nouvelles. Les SEULES modifications que je fais sur mon code pour utiliser les pointeurs à des Éléments, à l'exception d'une boucle-je ajouter de la mémoire de nettoyage à la fin. Ce programme s'exécute en moins de 40 secondes, ou mieux qu'un 10x augmentation de la vitesse.
EDIT: Le code est à http://pastebin.com/DK24SPeW
Avec les optimisations du compilateur, il montre seulement 3,4 x augmentation sur la machine, je l'ai juste testé sur, ce qui est encore considérable.