Comment allouer dynamiquement des tableaux en C++

allouer de la mémoire à l'aide de la new de l'opérateur et de libérer un pointeur à l'aide de delete de l'opérateur. Notez que vous ne pouvez pas supprimer des variables normales, seuls les pointeurs et les tableaux peuvent être supprimés après l'accomplissement de leur tâche.

int * foo;
foo = new int [5];
delete[] foo;

un programme complet

#include <iostream>
#include <new>
using namespace std;

int main ()
{
  int i,n;
  int * p;
  cout << "How many numbers would you like to type? ";
  cin >> i;
  p= new (nothrow) int[i];
  if (p == nullptr)
    cout << "Error: memory could not be allocated";
  else
  {
    for (n=0; n<i; n++)
    {
      cout << "Enter number: ";
      cin >> p[n];
    }
    cout << "You have entered: ";
    for (n=0; n<i; n++)
      cout << p[n] << ", ";
    delete[] p;
  }
  return 0;
}

résultat

How many numbers would you like to type? 5
Enter number : 75
Enter number : 436
Enter number : 1067
Enter number : 8
Enter number : 32
You have entered: 75, 436, 1067, 8, 32,

Vous devez être extrêmement prudent lors de l'utilisation brute des pointeurs avec dynamique de la mémoire, mais voici un exemple simple.

int main() {
    //Normal Pointer To Type
    int* pX = nullptr;
    pX = new int;
    *pX = 3;

    std::cout << *pX << std::endl;

    //Clean Up Memory
    delete pX;
    pX = nullptr;

    //Pointer To Array
    int* pXA = nullptr;
    pXA = new int[10]; //40 Bytes on 32bit - Not Initialized All Values Have Garbage
    pXA = new int[10](0); //40 Bytes on 32bit - All Values Initialized To 0.

    //Clean Up Memory To An Array Of Pointers.
    delete [] pXA;
    pXA = nullptr;

    return 0;     

} //main

Pour éviter les fuites de mémoire; pend des pointeurs, la suppression de la mémoire au début de l'etc. Essayez d'utiliser des pointeurs intelligents. Ils viennent dans deux variétés: partagé et unique.

SomeClass.h

#ifndef SOME_CLASS_H
#define SOME_CLASS_H

class SomeClass {
private:
    int m_x;

public:
    SomeClass();
    explicit SomeClass( x = 0 );

    void setX( int x );
    int  getX() const;

private:
    SomeClass( const SomeClass& c ); //Not Implemented - Copy Constructor
    SomeClass& operator=( const SomeClass& c ); Not Implemented - Overloaded Operator=
};  //SomeClass

#endif //SOME_CLASS_H

SomeClass.cpp

#include "SomeClass.h"

//SomeClass() - Default Constructor
SomeClass::SomeClass() :
m_x( x ) {
} //SomeClass

//SomeClass() - Constructor With Default Parameter
SomeClass::SomeClass( int x ) :
m_x( x ) {
} //SomeClass

//setX()
void SomeClass::setX( int x ) {
    m_x = x;
} //setX

//getX()
void SomeClass::getX() const {
    return m_x;
} //getX

Ancienne De L'Utilisation De La Mémoire Dynamique

#include <iostream>
#include "SomeClass.h"

int main() {
    //Single Dynamic Pointer
    SomeClass* pSomeClass = nullptr;

    pSomeClass = new SomeClass( 5 );

    std::cout << pSomeClass->getX() << std::endl;

    delete pSomeClass;
    pSomeClass = nullptr;

    //Dynamic Array 
    SomeClass* pSomeClasses = nullptr;
    pSomeClasses = new SomeClasses[5](); //Default Constructor Called


    for ( int i = 0; i < 5; i++ ) {
        pSomeClasses[i]->setX( i * 10 );
        std::cout << pSomeSomeClasses[i]->getX() << std::endl;
    }

    delete[] pSomeClasses;
    pSomeClasses = nullptr;  

    return 0;
} //main

Le problème ici est de savoir quand, où et pourquoi de supprimer de la mémoire; de savoir qui est responsable. Si vous effacer la mémoire de la gérer et de l'utilisateur de votre code ou de la bibliothèque suppose que vous n'avez pas et qu'ils le supprimer il y a un problème, puisque la même mémoire est d'essayer d'être supprimé à deux reprises. Si vous le laissez à l'utilisateur de les supprimer et ils ont supposé que vous avez fait et ils ne le font pas, vous avez un problème et il y a une fuite de mémoire. C'est là que l'utilisation des pointeurs intelligents venir dans maniable.

Smart Pointeur De La Version

#include <iostream>
#include <memory>
#include <vector>
#include "SomeClass.h"
int main() {
//SHARED POINTERS
//Shared Pointers Are Used When Different Resources Need To Use The Same Memory Block
//There Are Different Methods To Create And Initialize Shared Pointers
auto sp1 = std::make_shared<SomeClass>( 10 );
std::shared_ptr<SomeClass> sp2( new SomeClass( 15 ) );
std::shared_ptr<SomeClass> sp3;
sp3 = std::make_shared<SomeClass>( 20 );
std::cout << "SP1: " << sp1->getX() << std::endl;
std::cout << "SP2: " << sp2->getX() << std::endl;
std::cout << "SP3: " << sp3->getX() << std::endl;
//Now If you Reach The Return Of Main; These Smart Pointers Will Decrement
//Their Reference Count & When It Reaches 0; Its Destructor Should Be
//Called Freeing All Memory. This Is Safe, But Not Guaranteed. You Can
//Release & Reset The Memory Your Self.
sp1.reset();  
sp1 = nullptr;
sp2.reset();
sp2 = nullptr;
sp3.reset();
sp3 = nullptr;
//Need An Array Of Objects In Dynamic Memory?
std::vector<std::shared_ptr<SomeClass>> vSomeClasses;
vSomeClasses.push_back( std::make_shared<SomeClass>( 2 ) );
vSomeClasses.push_back( std::make_shared<SomeClass>( 4 ) );
vSomeClasses.push_back( std::make_shared<SomeClass>( 6 ) );
std::vector<std::shared_ptr<SomeClass>> vSomeClasses2;    
vSomeClasses2.push_back( std::shared_ptr<SomeClass>( new SomeClass( 3 ) ) );
vSomeClasses2.push_back( std::shared_ptr<SomeClass>( new SomeClass( 5 ) ) );
vSomeClasses2.push_back( std::shared_ptr<SomeClass>( new SomeClass( 7 ) ) );
//UNIQUE POINTERS
//Unique Pointers Are Used When Only One Resource Has Sole Ownership.
//The Syntax Is The Same For Unique Pointers As For Shared Just Replace
//std::shared_ptr<SomeClass> with std::unique_ptr<SomeClass> &
//replace std::make_shared<SomeClass> with std::make_unique<SomeClass>
//As For Release Memory It Is Basically The Same
//The One Difference With Unique Is That It Has A Release Method Where Shared Does Not.
auto mp1 = std::make_unique<SomeClass>( 3 );
mp1.release();
mp1.reset();
mp1 = nullptr;
//Now You Can Also Do This:
//Create A Unique Pointer To An Array Of 5 Integers
auto p = make_unique<int[]>( 5 );
//Initialize The Array
for ( int i = 0; i < 5; i++ ) {
p[i] = i;
}
return 0;
} //main

Ici Sont pour la Référence des Liens À la Fois Partagé & Unique Pointeurs

https://msdn.microsoft.com/en-us/library/hh279669.aspx

https://msdn.microsoft.com/en-us/library/hh279676.aspx