c++ qu'est-ce que “pointeur = new type” par opposition à “pointeur = new type []”?

Dans de nombreux tutoriels, le premier des exemples de code sur la mémoire dynamique commencer le long des lignes de:

int * pointer;
pointer = new int;        //version 1
//OR
pointer = new int [20];    //version 2

Ils toujours procéder à expliquer la manière dont la deuxième version fonctionne, mais totalement éviter de parler de la première version.

Ce que je veux savoir, c'est, qu'est - pointer = new int créer? Que puis-je faire avec? Ça veut dire quoi? Chaque tutoriel sans échec va éviter de parler de la première version entièrement. Tout ce que j'ai découvert (grâce à vous embêter) est-ce:

#include <iostream>

using namespace std;

int main()
{
    int * pointer;
    pointer = new int;
   pointer[2] = 1932;   //pointer [2] exists? and i can  assign to it?!
   cout << pointer[2] << endl;      //... and access it successfully?!
};

Le fait que je peux indice pointer me dit si loin que pointer = new int crée implicitement un tableau. Mais si oui, de quelle taille est-il?

Si quelqu'un pouvait aider à éclaircir tout cela pour moi, je lui en serais reconnaissant...

Notez également que la mémoire allouée avec nouveau doit être libérée avec supprimer, alors que la mémoire allouée avec [] doit être libérée avec delete [], ou d'une catastrophe peut se produire. Ils sont deux opérateurs différents. C'est l'un de la plus stupide des choses jamais inventé dans tout langage de programmation, et ce n'est pas une mince affaire à réaliser.
Il pourrait être votre compilateur qui est de vous aider un peu en allouant des tampons sur les deux côtés de ce que vous voulez. Vous pouvez lire à ce sujet ici - _malloc_dbg (CRT)
J'ai également trouvé ce utile avec c++ et de la mémoire en général: l'Allocation de la Mémoire
Curieux qu'un tutoriel en parler new int[n], et pas simplement new int. En plus de 20 ans de programmation en C++, je ne pense pas que je ai jamais utilisé un tableau new.
Je trouve cela intéressant... oh, et le site est cplusplus

OriginalL'auteur code shogan | 2011-05-18

  1. 13

    C'est une erreur classique en C et C++ pour les débutants. La première phrase, crée un espace pour la tenue juste une int. Le second crée un espace pour la tenue de 20 de ces ints. Dans les deux cas, cependant, il assigne l'adresse de début de la dynamique zone réservée à la pointer variable.

    Pour ajouter à la confusion, vous pouvez accéder à des pointeurs avec les indices que vous mettez pointer[2]), même lorsque la mémoire, ils sont de pointage n'est pas valide. Dans le cas de:

    int* pointer = new int;

    vous pouvez accéder à pointer[2], mais vous auriez un comportement indéfini. Notez que vous vérifier que ces accès ne sont pas réellement se produire, et le compilateur peut faire habituellement peu dans la prévention de ce type d'erreurs.

    Pouvez-vous nous expliquer ce qui n'int** pointeur = new int*[10] signifie? Merci!

    OriginalL'auteur Diego Sevilla

  2. 9

    Cela ne crée qu'un seul entier.

    pointer = new int;        //version 1

    Cela crée de 20 entiers.

    pointer = new int [20]    //version 2

    Ci-dessous n'est pas valide, puisque pointeur[2] traduit comme *(pointeur + 2) ; ce qui n'est pas été créé/allouée.

    int main()
{
    int * pointer;
    pointer = new int;
   pointer[2] = 1932;   //pointer [2] exists? and i can  assign to it?!
   cout << pointer[2] << endl;      //... and access it succesfuly?!
};

    Cheers!

    OriginalL'auteur Ricko M

  3. 9

    Mon professeur m'a expliqué comme ça.

    Penser le cinéma. La réelle sièges sont les allocations de mémoire et le billet que vous obtenez sont les pointeurs.

    int * pointer = new int;

    Ce serait une salle de cinéma avec un siège, et le pointeur serait le billet pour siège

    pointer = new int [20]

    Ce serait une salle de cinéma avec 20 sièges, et un pointeur serait le billet à la première place. pointeur[1] serait le billet pour le second siège de, et un pointeur[19] serait le billet pour le dernier siège.

    Lorsque vous ne int* pointer = new int; et ensuite accéder à pointer[2] vous êtes de permettre à quelqu'un de s'asseoir dans l'allée, un sens à un comportement indéterminé

    Je n'ai jamais entendu dire que l'analogie. Je l'aime, comment, concrètement, "assis dans les allées" est un comportement indéfini.

    OriginalL'auteur Default

  4. 2

    new int[20] alloue de la mémoire pour un entier tableau de taille 20, et renvoie un pointeur vers elle.

    new int simplement alloue de la mémoire pour un entier, et renvoie un pointeur vers elle. Implicitement, c'est le même que new int[1].

    Vous pouvez déréférencement (c'est à dire utiliser *p) sur les deux pointeurs, mais vous ne devez utiliser p[i] sur le pointeur retourné par la new int[20].

    p[0] continuera de fonctionner sur les deux, mais vous risquez de casser et de mettre un mauvais index par accident.

    Mise à jour: une Autre différence est que vous devez utiliser delete[] pour la matrice, et delete pour l'entier.

    new int n'est pas vraiment la même chose que new int[1] (en particulier, considèrent delete vs delete[]), mais je ne vois pourquoi vous avez dit que.
    Yep, je vais modifier la réponse.

    OriginalL'auteur evgeny

  5. 1

    pointer = new int alloue suffisamment de mémoire sur le tas pour stocker un int.

    pointer = new int [20] alloue de la mémoire pour stocker 20 ints.

    Deux appels renvoyer un pointeur vers la mémoire nouvellement allouée.

    Remarque: Ne comptez pas sur la mémoire allouée en cours d'initialisation, il peut contenir des valeurs aléatoires.

    OriginalL'auteur Tony the Pony

  6. 1

    pointer = new int; alloue un nombre entier et la stocke l'adresse de pointer. pointer[2] est synonyme de pointer + 2. Pour la comprendre, de lire à propos de l'arithmétique des pointeurs. Cette ligne est en fait un comportement indéfini, parce que vous êtes accédant à la mémoire que vous n'avez pas déjà allouer, et cela fonctionne parce que vous avez eu de la chance.

    +1 pour le "t'as de la chance"

    OriginalL'auteur Björn Pollex

  7. 1

    *"Le fait que je peux indice pointeur me dit si loin que je pointer = new int crée implicitement un tableau. mais si oui, de quelle taille est-il?"
    *

    C'est la partie de la question qui me plaisait le plus et qui vous le soulignez.

    Comme nous le savons tous l'allocation de mémoire dynamique rend l'utilisation de l'espace sur la Pile, qui est spécifique à la programme donné.
    Quand on regarde de plus près sur la définition d'un nouvel opérateur :-

    void* operator new[] (std::size_t size) throw (std::bad_alloc);

    Ce qui représente en fait un tableau d'objets de la taille et si c'est réussi, qu'il est automatiquement Constructions chacun des Objets dans le tableau. Ainsi, nous sommes libres d'utiliser les objets dans la limite de la taille, car il a déjà été initialisé/construit.

    int * pointer = new int;

    Sur l'autre main pour l'exemple ci-dessus il y a toutes les possibilités d'un comportement indéfini lorsque l'un quelconque de 

    *(pointer + k) or *(k + pointer)

    sont utilisés. Si les emplacement mémoire peut être consulté à l'utilisation de pointeurs, il n'y a aucune garantie parce que l'Objet particulier pour le même n'a pas été créé ni construits.Cela peut être considéré comme un espace qui n'a pas été alloué sur la Pile pour le programme particulier.

    Espère que cette aide.

    Je n'aurais jamais pensé dire ça, mais une erreur serait mieux que tout cela undefined behavior. 😉
    je pense que tu veux dire "en tas", pas "pile" -- les variables locales sont sur la pile, les allocations dynamiques sont sur le tas, en général

    OriginalL'auteur NirmalGeo

  8. 0

    int* p = new int alloue de la mémoire pour un entier. Il n'est pas implictly créer un tableau. La manière dont vous accédez au pointeur à l'aide de p[2] sera la cause du comportement indéfini comme vous l'écrivez un emplacement de mémoire non valide. Vous pouvez créer un tableau uniquement si vous utilisez new[] de la syntaxe. Dans un tel cas, vous devez libérer de la mémoire à l'aide de delete[]. Si vous avez la mémoire allouée à l'aide de new cela signifie que vous sont en train de créer un objet unique et vous avez besoin de libérer de la mémoire à l'aide de delete.

    OriginalL'auteur Naveen

  9. 0

    Il n'a pas de création de matrice. Il crée un entier et retourne le pointeur de cet entier. Lorsque vous écrivez un pointeur[2] référence à une mémoire qui n'ont pas alloué. Vous avez besoin d'être prudent et de ne pas le faire. Cette mémoire peut être modifié par le programme externe qui vous permet, je pense, ne veulent pas.

    OriginalL'auteur Narek

  10. 0
    int * pointer; pointer = new int;  //version 1
//OR 
pointer = new int [20]             //version 2

    ce que je veux savoir, c'est, qu'est - pointer = new int créer? que puis-je faire avec? ça veut dire quoi? Chaque tutoriel sans échec va éviter de parler de la première version entièrement

    La raison pour laquelle le didacticiel ne pas les remplir, vous avez de quoi faire avec c'est qu'il est vraiment est totalement inutile! Il alloue un seul int et vous donne un pointeur.

    Le problème est que si vous voulez un int, pourquoi ne pas vous déclarer?

    int i;
    selon le lien que j'ai posté ci-dessous ma question, il a un but. Si je n'ai int i alors la mémoire car je serait réservé dès que le programme entre dans runtime et continueront de l'être réservés jusqu'à ce qu'il quitte. Le problème, c'est lorsque vous souhaitez stocker quelque chose pendant un certain temps, surtout si vous programme est énorme et l'excecution chemins varient grandement. puis new int i entre en jeu. Maintenant, je n'aurais pas besoin de ce jour, mais je voulais la comprendre et de savoir comment l'utiliser si jamais besoin d'être.
    shogan - Le problème avec l'exemple, c'est que le pointeur de la int prend au moins autant d'espace que la int lui-même. Ce qui en fait une perte nette. Si vous avez besoin de votre entier seulement parfois, vous pouvez la déclarer à l'intérieur d'une fonction. Puis il va vivre aussi longtemps que la fonction est active.
    ...et je wount ont pour delete pointer. Bon, je donne en new int; est un peu inutile.:)

    OriginalL'auteur Bo Persson