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;

表示单个元素。

但是使用矢量或使用智能指针更简单，那么你不必担心内存管理。

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

这里的问题是知道删除内存的时间，地点和原因;知道谁负责。如果删除内存以对其进行管理，并且代码或库的用户假定您没有删除它，则会出现问题，因为同一内存尝试删除两次。如果你把它留给用户删除它，他们认为你做了，他们没有你有问题，并有内存泄漏。这是使用智能指针派上用场的地方。

智能指针版本

#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

以下是共享链接和共享链接独特的指针

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

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

Answer 5

以下信息将非常有用：来源：https://www.learncpp.com/cpp-tutorial/6-9a-dynamically-allocating-arrays/

初始化动态分配的数组

如果要将动态分配的数组初始化为0，则语法非常简单：

int *array = new int[length]();

在C ++ 11之前，没有简单的方法可以将动态数组初始化为非零值（初始化程序列表仅适用于固定数组）。这意味着您必须遍历数组并显式分配元素值。

int *array = new int[5];
array[0] = 9;
array[1] = 7;
array[2] = 5;
array[3] = 3;
array[4] = 1;

超级烦人！

但是，从C ++ 11开始，现在可以使用初始化列表初始化动态数组！

int fixedArray[5] = { 9, 7, 5, 3, 1 }; // initialize a fixed array in C++03
int *array = new int[5] { 9, 7, 5, 3, 1 }; // initialize a dynamic array in C++11

请注意，此语法在数组长度和初始化程序列表之间没有operator =。

为了一致性，在C ++ 11中，还可以使用统一初始化来初始化固定数组：

int fixedArray[5] { 9, 7, 5, 3, 1 }; // initialize a fixed array in C++11
char fixedArray[14] { "Hello, world!" }; // initialize a fixed array in C++11

一个警告，在C ++ 11中，您不能从C样式字符串初始化动态分配的char数组：

char *array = new char[14] { "Hello, world!" }; // doesn't work in C++11

如果需要执行此操作，请动态分配std :: string（或分配char数组，然后将字符串作为字符串）。

还请注意，动态数组必须以明确的长度声明：

int fixedArray[] {1, 2, 3}; // okay: implicit array size for fixed arrays

int *dynamicArray1 = new int[] {1, 2, 3}; // not okay: implicit size for dynamic arrays

int *dynamicArray2 = new int[3] {1, 2, 3}; // okay: explicit size for dynamic arrays

如何在C ++中动态分配数组

5 个答案: