Как динамически выделять массивы в C++

Question

Я знаю, как динамически выделять место для массива в C. Это может быть сделано следующим образом:

L = (int*)malloc(mid*sizeof(int)); 

и память может быть освобожден:

free(L); 

Как достичь эквивалента в C++?

В частности, как использовать ключевые слова new и delete[]? Особенно в контексте создания/уничтожения узла связанного списка или создания и уничтожения массива, размер которого задается переменной во время компиляции?

Answer 1

L = new int[mid]; 
delete[] L; 

для массивов (что вы хотите) или

L = new int; 
delete L; 

для отдельных элементов.

Но это более простой в использовании вектор или использование smartpointers, тогда вам не нужно беспокоиться об управлении памятью.

std::vector<int> L(mid); 

L.data() дает вам доступ к буферу int[] массива, и вы можете L.resize() вектор позже.

auto L = std::make_unique<int[]>(mid); 

L.get() дает указатель на int[] массив.

Answer 2

Вы назначаете память с помощью оператора new и освобождаете указатель с помощью оператора delete. Обратите внимание, что вы не можете удалить обычные переменные, после выполнения их задачи можно удалить только указатели и массивы.

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

полная программа

#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; 
} 

результат

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, 

Answer 3

В C++ есть методы для выделения и отмены размещения динамической памяти.Переменные могут быть динамически выделяются с помощью new оператора, как,

     type_name *variable_name = new type_name; 

массивы не что иное, как просто набор смежных ячеек памяти, поэтому, мы можем динамически выделять массивы в C++, как,

     type_name *array_name = new type_name[SIZE]; 

и вы можете просто использовать delete для высвобождения динамически распределенного пространства, как следует, для переменных,

     delete variable_name; 

для массивов,

     delete[] array_name; 

Answer 4

Вы должны быть очень осторожны при использовании сырых указателей с динамической памятью, но вот простой пример.

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 

Во избежание утечек памяти; висячие указатели, удаление памяти до начала и т. д. Попробуйте использовать интеллектуальные указатели. Они бывают двух разновидностей: общие и уникальные.

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 

Старый способ использования динамической памяти

#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 

Проблема здесь в том, чтобы знать, когда, где и зачем удалять память; зная, кто несет ответственность. Если вы удаляете память для ее управления, а пользователь вашего кода или библиотеки предполагает, что вы этого не сделали, и они удаляют его, возникает проблема, так как одна и та же память пытается удалить дважды. Если вы оставите его пользователю, чтобы удалить его, и они предположили, что сделали, и у вас нет проблем, и есть утечка памяти. Здесь полезно использовать интеллектуальные указатели.

Смарт Pointer Версия

#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 

Здесь даны ссылки Ссылки на оба общей & Unique легавых

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

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