C++ || 动态数组

最新推荐文章于 2024-09-27 20:36:49 发布
最新推荐文章于 2024-09-27 20:36:49 发布
阅读量1.2k 收藏 3
点赞数
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_63378697/article/details/130157500
版权
本文介绍了C++中的动态内存分配，包括使用new运算符申请和释放内存，以及如何处理动态数组。文中展示了动态数组的创建、访问和释放，以及通过封装成类来更好地管理和检查边界。此外，文章还涉及了类的构造函数、析构函数、复制构造函数和深拷贝的实现，强调了内存管理的重要性。
摘要由CSDN通过智能技术生成

1.动态内存分配：

动态申请内存操作符 new

        new 类型名T（初始化参数列表）

功能：在程序执行期间，申请用于存放T类型对象的内存空间，并依初值列表赋以初值。

结果值：成功：T类型的指针，指向新分配的内存；失败：抛出异常。

        释放内存操作符delete

        delete 指针p

功能：释放指针p所指向的内存。p必须是new操作的返回值。

#include <iostream>
using namespace std;
class Point {
public:
	Point();
	Point(int x, int y);
	~Point();
	int getX() const; 
	int getY() const; 
	void move(int newX, int newY);
private:
	int x, y;
};

Point::Point() : x(0), y(0) {
    cout<<"Default Constructor called."<<endl;
}
Point::Point(int x, int y) : x(x), y(y) {
    cout<< "Constructor called."<<endl;
}
Point::~Point() { cout<<"Destructor called."<<endl; }
int Point::getX() const { return x; }
int Point::getY() const { return y; }
void Point::move(int newX, int newY) {
    x = newX;
    y = newY;
}


int main(){
	cout << "Step one: " << endl;
	Point *ptr1 = new Point; //调用默认构造函数
	cout<<ptr1->getX()<<endl; //输出GetX
	delete ptr1; //删除对象，自动调用析构函数
	cout << "Step two: " << endl;
	ptr1 = new Point(1,2);
	cout<<ptr1->getX()<<endl; //输出GetX
	delete ptr1;
	return 0;
}

2.

分配和释放动态数组

  • 分配：new 类型名T [ 数组长度 ]

    • 数组长度可以是任何表达式，在运行时计算

  • 释放：delete[] 数组名p

    • 释放指针p所指向的数组。
      p必须是用new分配得到的数组首地址。


#include <iostream>

using namespace std;

class Point {

public:

	Point() : x(0), y(0) {
	cout<<"Default Constructor called."<<endl;
	}

	Point(int x, int y) : x(x), y(y) {
		cout<< "Constructor called."<<endl;
	}
	~Point() { cout<<"Destructor called."<<endl; }

	int getX() const { return x; }
	int getY() const { return y; }
	void move(int newX, int newY) {
		x = newX;
		y = newY;
	}

	private:
		int x, y;
};

int main() {
	Point *ptr = new Point[2]; //创建对象数组
	ptr[0].move(5, 10); //通过指针访问数组元素的成员
	cout<<ptr[0].getY()<<endl;
	ptr[1].move(15, 20); //通过指针访问数组元素的成员
	cout<<ptr[1].getY()<<endl;   
	cout << "Deleting..." << endl;
	delete[] ptr; //删除整个对象数组
	return 0;
}

3.将动态数组封装成类

  • 更加简洁，便于管理

  • 可以在访问数组元素前检查下标是否越界

#include <iostream>
#include <cassert>
using namespace std;
class Point {
	private:
		int x, y;
	public:
		Point() : x(0), y(0) {
			cout << "Default Constructor called." << endl;
		}
		Point(int x, int y) : x(x), y(y) {
			cout << "Constructor called." << endl;
		}
		~Point() { cout << "Destructor called." << endl; }
		int getX() const { return x; }
		int getY() const { return y; }
		void move(int newX, int newY) {
			x = newX;
			y = newY;
		}

};

class ArrayOfPoints { //动态数组类
	private:
		Point *points; //指向动态数组首地址
		int size; //数组大小
	public:
		ArrayOfPoints(int size) : size(size) {
			points = new Point[size];
		}
		~ArrayOfPoints() {
			cout << "Deleting..." << endl;
			delete[] points;
		}
		Point& element(int index) {
			assert(index >= 0 && index < size);
			return points[index];
		}
};

int main() {
	int count;
	cout << "Please enter the number of points: ";
	cin >> count;
	ArrayOfPoints points(count); //创建数组对象
	points.element(0).move(5, 0); //访问数组元素的成员
	points.element(1).move(15, 20); //访问数组元素的成员
	return 0;
}

4.动态数组，是相对于静态数组而言。静态数组的长度是编程时程序员预先定义好的，在整个程序运行中，数组大小无法改变。而动态数组则不然，它可以随程序运行的需要而在运行时重新指定大小。

        动态数组的内存空间是从堆（heap）上分配（即动态分配）的。是通过执行new（或malloc等函数）操作，而为其分配存储空间。当程序执行到这些语句时，才为其分配。

        对于动态数组类所申请的内存，在使用完必须由程序员自己释放，否则严重会引起内存泄露。所以内存的申请一定要有借有还，才能再借不难，也要注意，不能多还。

        已知动态数组模板类的定义如下。

请补充完整

        1)构造函数

        2)析构函数

        3)返回空间大小的 capacity()  函数

        4)operator[] 重载

#include <cstring>
#include <iostream>
 
using namespace std;
 
class Point {
    int x, y;
 
   public:
    // constructor
    Point(int _x = 0, int _y = 0);
    // deconstructor
    ~Point();
    // cout <<  overload
    friend ostream& operator<<(ostream& os, const Point& p);
};
 
Point::Point(int _x, int _y) {
    this->x = _x;
    this->y = _y;
    cout << "\nPoint is called!";
}
 
Point::~Point() { cout << "\n~Point is called!"; }
 
ostream& operator<<(ostream& os, const Point& p) {
    cout << "(" << p.x << "," << p.y << ")";
    return os;
}
 
template <typename T>
class DynamicArray {
   private:
    T* array;                 // pointer
    unsigned int mallocSize;  // the length of dynamic array
 
   public:
    // Constructors
    // mallocSize=length, and the new element is content
    DynamicArray(unsigned length, const T& content);
 
    // Destructors
    ~DynamicArray();
 
    // Copy Constructor
    DynamicArray(const DynamicArray<T>& anotherDA);
 
    // return the this->mallocSize
    unsigned int capacity() const;
 
    // for the array[i]=someT.
    T& operator[](unsigned int i);

};
 
template <typename T>
DynamicArray<T>::DynamicArray(unsigned length, const T& content) {
    this->mallocSize = length;
    cout << endl
         << "new T[" << this->mallocSize << "] malloc " << this->mallocSize
         << "*" << sizeof(T) << "=" << this->mallocSize * sizeof(T)
         << " bytes memory in heap";
    this->array = new T[this->mallocSize];
    for (int i = 0; i < length; ++i) {
        this->array[i] = content;
    }
};
 
template <typename T>
DynamicArray<T>::~DynamicArray() {
    cout << endl
         << "delete[] array free " << this->mallocSize << "*" << sizeof(T)
         << "=" << this->mallocSize * sizeof(T) << " bytes memory in heap";
    delete[] array;
};
  
template <typename T>
unsigned int DynamicArray<T>::capacity() const {
    return this->mallocSize;
}
 
template <typename T>
T& DynamicArray<T>::operator[](unsigned int i) {
    return this->array[i];
}
 
int main()
{
    int length,i;
    cin>> length;

    DynamicArray<int> iarray(length,-1);
    DynamicArray<double> darray(length,-2.1);

    cout<<endl<<"capacity:"<<iarray.capacity()<<endl;

    for(i=0;i<length;i++) {
        cout << iarray[i] <<" ";
        iarray[i] = i*1.1;
    }
    cout<<endl;
    for(i=0;i<length;i++) {
        cout << darray[i] <<" ";
        darray[i] = i*1.1;
    }
    cout<<endl;
    for(i=0;i<length;i++) {
        cout << iarray[i] <<" ";
        iarray[i] = i*1.1;
    }
    cout<<endl;
    for(i=0;i<length;i++) {
        cout << darray[i] <<" ";
    }
}

         5)operator[]  const 重载

template <typename T>
class DynamicArray {
private:
T* array; //pointer  ，一个T类型的指针
unsigned int mallocSize; //分配空间的大小。

public:
//Constructors 
// cout<<endl<< "new T["<<this->mallocSize<<"] malloc "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
DynamicArray(unsigned length, const T &content) ; // mallocSize=length; 设置每个元素的初始内容是 content；

// Destructors
// cout<<endl<< "delete[] array free "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
~DynamicArray();

//return the this->mallocSize
unsigned int capacity() const;

// for the array[i]=someT.
T& operator[](unsigned int i) ;

//自己定义个operator[]  const 重载
T& operator[] (unsigned int i) const;

};

template <typename T>
DynamicArray<T>::DynamicArray(unsigned length, const T& content) {
    this->mallocSize = length;
    cout << endl
         << "new T[" << this->mallocSize << "] malloc " << this->mallocSize
         << "*" << sizeof(T) << "=" << this->mallocSize * sizeof(T)
         << " bytes memory in heap";
    this->array = new T[this->mallocSize];
    for (int i = 0; i < length; ++i) {
        this->array[i] = content;
    }
};
 
template <typename T>
DynamicArray<T>::~DynamicArray() {
    cout << endl
         << "delete[] array free " << this->mallocSize << "*" << sizeof(T)
         << "=" << this->mallocSize * sizeof(T) << " bytes memory in heap";
    delete[] array;
};
  
template <typename T>
unsigned int DynamicArray<T>::capacity() const {
    return this->mallocSize;
}
 
template <typename T>
T& DynamicArray<T>::operator[](unsigned int i) {
    return this->array[i];
}

template <typename T>
T& DynamicArray<T>::operator[](unsigned int i) const{
    return this->array[i];
}

        6)实现一个copy构造函数

#include <cstring>
#include <iostream>
 
using namespace std;
 
class Point {
    int x, y;
 
   public:
    // constructor
    Point(int _x = 0, int _y = 0);
    // deconstructor
    ~Point();
    // cout <<  overload
    friend ostream& operator<<(ostream& os, const Point& p);
};
 
Point::Point(int _x, int _y) {
    this->x = _x;
    this->y = _y;
    cout << "\nPoint is called!";
}
 
Point::~Point() { cout << "\n~Point is called!"; }
 
ostream& operator<<(ostream& os, const Point& p) {
    cout << "(" << p.x << "," << p.y << ")";
    return os;
}
 

template <typename T>
class DynamicArray {
private:
T* array; //pointer  ，一个T类型的指针
unsigned int mallocSize; //分配空间的大小。

public:
//Constructors 
// cout<<endl<< "new T["<<this->mallocSize<<"] malloc "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
DynamicArray(unsigned length, const T &content) ; // mallocSize=length; 设置每个元素的初始内容是 content；

//Copy Constructor
// cout<<endl<< "Copy Constructor is called";
DynamicArray(const DynamicArray<T> & anotherDA ) ;

// Destructors
// cout<<endl<< "delete[] array free "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
~DynamicArray();

//return the this->mallocSize
unsigned int capacity() const;

// for the array[i]=someT.
T& operator[](unsigned int i) ;

//自己定义个operator[]  const 重载
};



template <typename T>
DynamicArray<T>::DynamicArray(unsigned length, const T& content) {
    this->mallocSize = length;
    cout << endl
         << "new T[" << this->mallocSize << "] malloc " << this->mallocSize
         << "*" << sizeof(T) << "=" << this->mallocSize * sizeof(T)
         << " bytes memory in heap";
    this->array = new T[this->mallocSize];
    for (int i = 0; i < length; ++i) {
        this->array[i] = content;
    }
};
 
template <typename T>
DynamicArray<T>::~DynamicArray() {
    cout << endl
         << "delete[] array free " << this->mallocSize << "*" << sizeof(T)
         << "=" << this->mallocSize * sizeof(T) << " bytes memory in heap";
    delete[] array;
};
 
template <typename T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& anotherDA) {
    // this = anotherDA;
    cout << endl << "Copy Constructor is called";
    this->mallocSize = anotherDA.mallocSize;
    this->array = new T[this->mallocSize];
    for (int i = 0; i < this->mallocSize; ++i)
        this->array[i] = anotherDA.array[i];
};
 

template <typename T>
unsigned int DynamicArray<T>::capacity() const {
    return this->mallocSize;
}
 
template <typename T>
T& DynamicArray<T>::operator[](unsigned int i) {
    return this->array[i];
}
 

int main()
{
int length,i;
cin>> length;

DynamicArray<int> iarray(length,-1);

DynamicArray<int> iarray2(iarray);

cout<<endl;
for(i=0;i<length;i++) {
	cout << iarray[i] <<" ";
	iarray[i] = i*1.1;
}
cout<<endl;
for(i=0;i<length;i++) {
	cout << iarray2[i] <<" ";	
}

return 0;
}

        7)实现深赋值，操作符= 的重载

#include <cstring>
#include <iostream>
 
using namespace std;
 
class Point {
    int x, y;
 
   public:
    // constructor
    Point(int _x = 0, int _y = 0);
    // deconstructor
    ~Point();
    // cout <<  overload
    friend ostream& operator<<(ostream& os, const Point& p);
};
 
Point::Point(int _x, int _y) {
    this->x = _x;
    this->y = _y;
    cout << "\nPoint is called!";
}
 
Point::~Point() { cout << "\n~Point is called!"; }
 
ostream& operator<<(ostream& os, const Point& p) {
    cout << "(" << p.x << "," << p.y << ")";
    return os;
}
 
template <typename T>
class DynamicArray {
private:
T* array; //pointer  ，一个T类型的指针
unsigned int mallocSize; //分配空间的大小。

public:
//Constructors 
// cout<<endl<< "new T["<<this->mallocSize<<"] malloc "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
DynamicArray(unsigned length, const T &content) ; // mallocSize=length; 设置每个元素的初始内容是 content；

//Copy Constructor
// cout<<endl<< "Copy Constructor is called";
DynamicArray(const DynamicArray<T> & anotherDA ) ;

// Destructors
// cout<<endl<< "delete[] array free "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
~DynamicArray();

//return the this->mallocSize
unsigned int capacity() const;

// for the array[i]=someT.
T& operator[](unsigned int i) ;

//自己定义个operator[]  const 重载

//自己定义个 operator = 重载

// 函数内要输出  cout<<endl<<"operator = is called";

DynamicArray<T> & operator= (const DynamicArray<T> & anotherDA ) ;

};


template <typename T>
DynamicArray<T>::DynamicArray(unsigned length, const T& content) {
    this->mallocSize = length;
    cout << endl
         << "new T[" << this->mallocSize << "] malloc " << this->mallocSize
         << "*" << sizeof(T) << "=" << this->mallocSize * sizeof(T)
         << " bytes memory in heap";
    this->array = new T[this->mallocSize];
    for (int i = 0; i < length; ++i) {
        this->array[i] = content;
    }
};
 
template <typename T>
DynamicArray<T>::~DynamicArray() {
    cout << endl
         << "delete[] array free " << this->mallocSize << "*" << sizeof(T)
         << "=" << this->mallocSize * sizeof(T) << " bytes memory in heap";
    delete[] array;
};
 
template <typename T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& anotherDA) {
    // this = anotherDA;
    cout << endl << "Copy Constructor is called";
    this->mallocSize = anotherDA.mallocSize;
    this->array = new T[this->mallocSize];
    for (int i = 0; i < this->mallocSize; ++i)
        this->array[i] = anotherDA.array[i];
};
 
template <typename T>
DynamicArray<T>& DynamicArray<T>::operator=(const DynamicArray<T>& anotherDA) {
    cout << endl << "operator = is called";
    if (this == &anotherDA) return *this;
    if (this->array) delete[] this->array;
    this->mallocSize = anotherDA.mallocSize;
    this->array = new T[this->mallocSize];
    for (int i = 0; i < this->mallocSize; ++i)
        this->array[i] = anotherDA.array[i];
    return *this;
}
 
template <typename T>
unsigned int DynamicArray<T>::capacity() const {
    return this->mallocSize;
}
 
template <typename T>
T& DynamicArray<T>::operator[](unsigned int i) {
    return this->array[i];
}
 
int main()
{
int length,i;
cin>> length;

DynamicArray<int> iarray(length,-1);

DynamicArray<int> iarray2(iarray),iarray3(iarray2);

cout<<endl;
for(i=0;i<length;i++) {
	cout << iarray3[i] <<" ";
	iarray[i] = i*1.1;	
}
iarray3=iarray2=iarray;
cout<<endl;
for(i=0;i<length;i++) {
	cout << iarray3[i] <<" ";	
}

return 0;
}

        8)实现深赋值，操作符= 的重载

                Point类动态数组应用

                实现一个Point类，实现

                class Point {
                     int x,y;
                     public:
                            //构造函数，输出 cout<<"\nPoint is called!";  并完成私有成员的初始化

                            //析构函数，输出    cout<<"\n~Point is called!";

                           //友元输出函数，输出   "("<<p.x<<","<<p.y<<")";
                  };

#include <cstring>
#include <iostream>
 
using namespace std;
 
class Point {
    int x, y;
 
   public:
    // constructor
    Point(int _x = 0, int _y = 0);
    // deconstructor
    ~Point();
    // cout <<  overload
    friend ostream& operator<<(ostream& os, const Point& p);
};
 
Point::Point(int _x, int _y) {
    this->x = _x;
    this->y = _y;
    cout << "\nPoint is called!";
}
 
Point::~Point() { cout << "\n~Point is called!"; }
 
ostream& operator<<(ostream& os, const Point& p) {
    cout << "(" << p.x << "," << p.y << ")";
    return os;
}
 
template <typename T>
class DynamicArray {
   private:
    T* array;                 // pointer
    unsigned int mallocSize;  // the length of dynamic array

    
	public:
	//Constructors 
	// cout<<endl<< "new T["<<this->mallocSize<<"] malloc "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
	DynamicArray(unsigned length, const T &content) ; // mallocSize=length; 设置每个元素的初始内容是 content；
	
	//Copy Constructor
	// cout<<endl<< "Copy Constructor is called";
	DynamicArray(const DynamicArray<T> & anotherDA ) ;
	
	// Destructors
	// cout<<endl<< "delete[] array free "<< this->mallocSize << "*"<<sizeof(T)<<"="<<this->mallocSize *sizeof(T)<<" bytes memory in heap";
	~DynamicArray();
	
	//return the this->mallocSize
	unsigned int capacity() const;
	
	// for the array[i]=someT.
	T& operator[](unsigned int i) ;   
	 //自己定义个operator[]  const 重载
	
	//自己定义个 operator = 重载
	
	// 函数内要输出  cout<<endl<<"operator = is called";
    DynamicArray<T>& operator=(const DynamicArray<T>& anotherDA);
};
 
template <typename T>
DynamicArray<T>::DynamicArray(unsigned length, const T& content) {
    this->mallocSize = length;
    cout << endl
         << "new T[" << this->mallocSize << "] malloc " << this->mallocSize
         << "*" << sizeof(T) << "=" << this->mallocSize * sizeof(T)
         << " bytes memory in heap";
    this->array = new T[this->mallocSize];
    for (int i = 0; i < length; ++i) {
        this->array[i] = content;
    }
};
 
template <typename T>
DynamicArray<T>::~DynamicArray() {
    cout << endl
         << "delete[] array free " << this->mallocSize << "*" << sizeof(T)
         << "=" << this->mallocSize * sizeof(T) << " bytes memory in heap";
    delete[] array;
};
 
template <typename T>
DynamicArray<T>::DynamicArray(const DynamicArray<T>& anotherDA) {
    // this = anotherDA;
    cout << endl << "Copy Constructor is called";
    this->mallocSize = anotherDA.mallocSize;
    this->array = new T[this->mallocSize];
    for (int i = 0; i < this->mallocSize; ++i)
        this->array[i] = anotherDA.array[i];
};
 
template <typename T>
DynamicArray<T>& DynamicArray<T>::operator=(const DynamicArray<T>& anotherDA) {
    cout << endl << "operator = is called";
    if (this == &anotherDA) return *this;
    if (this->array) delete[] this->array;
    this->mallocSize = anotherDA.mallocSize;
    this->array = new T[this->mallocSize];
    for (int i = 0; i < this->mallocSize; ++i)
        this->array[i] = anotherDA.array[i];
    return *this;
}
 
template <typename T>
unsigned int DynamicArray<T>::capacity() const {
    return this->mallocSize;
}
 
template <typename T>
T& DynamicArray<T>::operator[](unsigned int i) {
    return this->array[i];
}
 
int main()
{
int length,i;
cin>> length;

DynamicArray<Point> iarray(length,Point(3));

DynamicArray<Point> iarray2(iarray),iarray3(iarray2);

cout<<endl;
for(i=0;i<length;i++) {
	cout << iarray3[i] <<" ";
	iarray[i] = Point(i,i+1);	
}
iarray3=iarray2=iarray;
cout<<endl;
for(i=0;i<length;i++) {
	cout << iarray3[i] <<" ";	
}

return 0;
}
小嘤嘤怪学
关注
专栏目录
C++实现动态数组功能
01-20
1.线性表：数据存储像一条线一样的结构，每个线性表上的数据最多只有前和后的两个方向，如数组、链表、队列、栈等都是这种结构，所以实现的数组的动态操作，其他结构也可轻易的类似实现。更重要的是，在这之后看源码...
C语言动态分配数组
吻等离子的博客
03-26 883
可以使用指针，并在需要时通过malloc函数动态分配内存。在这个示例中，结构体包含了一个整型成员size表示数组的大小，以及一个整型指针array用于存储动态数组。在函数中，我们通过malloc函数为数组分配内存，然后将分配的内存地址赋值给array成员。在main函数中，我们可以通过结构体变量访问并操作这个动态数组。最后，在程序结束前，我们使用函数释放了动态分配的内存，以避免内存泄漏。
C++数组之动态数组
weixin_61627067的博客
03-15 1万+
c++ 数组
C++动态数组详解
最新发布
austinchr3377的博客
09-27 362
概念详解静态数组：在编译时确定大小，一旦分配就不能改变。创建了一个包含 10 个整数的数组。动态数组：在运行时根据需要分配和调整大小。可以在程序运行过程中增加或减少其大小。例如，使用new和delete或者。动态数组是 C++ 中非常有用的数据结构，尤其适合那些需要在运行时根据实际情况调整大小的场景。虽然使用new和delete可以更直接地控制内存，但提供了更加安全和便捷的方式。选择哪种方法取决于具体的应用需求和个人偏好。在大多数情况下，推荐使用。
c++ 动态数组
m0_62870588的博客
03-31 2万+
动态数组 ；使用malloc()和free()动态分配 ；使用new 和delete 两个操作符 ；new/delete 与malloc()/free()的区别。
c++动态数组
热门推荐
manchengpiaoxue的博客
10-18 9万+
注意：静态数组是在堆栈上（不需要自行释放空间）创建，动态数组是在堆上创建（需要自行释放空间） 涉及内容： 堆（heap）-自由存储区（free store） C语言：malloc和free c++语言：new和delete 1.动态数组定义（见后面） 2.初始化动态数组分配 string *p_string = new string[10]; //默认的构造函数初始化 Dog *p...
C/C++数据结构之动态数组篇
qq_63883017的博客
11-05 9667
手把手带你从初识动态数组到手写简单版本的c++vector容器
C++学习之动态数组
qq_46454669的博客
09-03 3271
则*pw = 1000，若加入一行代码pw = pw + 1，则*pw = 2000，同理，*ps = 3，若加入一行代码ps = ps + 1，*ps = 2。C++新增了模板类array，与数组一样，array对象的数组长度是固定的，也使用栈（静态内存分配），而不是自由存储区，因此效率与数组相同，但更方便更安全。会编译出一个可执行的1.exe文件，执行./1.exe，最终会运行程序，输出为。另一种访问结构成员的方法是，如果ps是指向结构的指针，则*ps就是被指向的结构本身，由于*ps是一个结构，因此。
动态数组C++实现2
06-19
在C++编程语言中，动态数组是一种非常重要的数据结构，它允许程序员在程序运行时根据需要动态地分配和释放内存。动态数组的概念与传统的静态数组不同，静态数组在编译时就必须确定其大小，而动态数组则可以在运行时...
C++动态数组类的封装实例
09-04
在C++编程中，动态数组是一种非常重要的数据结构，它允许程序员在运行时根据需要动态地改变数组的大小。为了更好地管理和使用动态数组，我们可以对其进行封装，将其抽象成一个类。下面将详细介绍C++动态数组类封装...
C++中关于[]静态数组和new分配的动态数组的区别分析
09-04
在C++编程语言中，数组是一种基本的数据结构，分为静态数组和动态数组两种类型。静态数组和动态数组在使用上有显著的区别，这些差异主要体现在内存分配、大小确定、生命周期以及内存管理等方面。 首先，静态数组在...
C++ 动态数组
恋恋风辰的技术博客
01-21 1万+
C++语言和标准库提供了两种一次分配一个对象数组的方法。C++语言定义了另一种new表达式语法，可以分配并初始化一个对象数组。标准库中包含一个名为allocator的类，允许我们将分配和初始化分离。使用allocator通常会提供更好的性能和更灵活的内存管理能力。 new和数组 为了让new分配一个对象数组，我们要在类型名之后跟一对方括号，在其中指明要分配的对象的数目。在下例中，new分配要求数量的对象并（假定分配成功后）返回指向第一个对象的指针： int get_size_new() { ret
7.1 C/C++ 实现动态数组
CSDN
08-15 5271
动态数组相比于静态数组具有更大的灵活性，因为其大小可以在运行时根据程序的需要动态地进行分配和调整，而不需要在编译时就确定数组的大小。这使得动态数组非常适合于需要动态添加或删除元素的情况，因为它们可以在不浪费空间的情况下根据需要动态增加或减少存储空间。 动态数组的内存空间是从堆(heap)上分配的，动态数组需要程序员手动管理内存，因为它们的内存空间是在程序运行时动态分配的。程序员需要在使用完动态数组后手动释放其内存空间，否则可能会导致内存泄漏的问题，进而导致程序崩溃或者运行缓慢。因此，在使用动态数组时，程序
【C++】动态数组
发现问题，并解决问题，批判性思维
01-20 2552
一、动态数组 回顾计算机内存中按照用途被划分的5个区域： //存储在栈 int x=0; int *p=NULL; //存储在堆区，注意这里的数组名为p，而不是int(关键字int) int *p=new int[20]; //全局区 存储全局变量和静态变量 //常量区 string str="hello"; //代码区 存储逻辑代码的二进制 那啥时候我们需要定义动态数组呢？ 【答】很多情况下，在预编译过程阶段，数组的长度是不能预先知道的，必须在程序运行时动态的给出 但是问题是，c++要求定义数
C++ STL之 vector（动态数组）详解
zdlzf的博客
06-16 5773
vector为可变长数组（动态数组），定义的vector数组可以随时添加数值和删除元素。在局部函数中开vector数组，是在堆空间里面开的，与开全局变量比较类似，所以经常见到在局部函数中开大容量数组。1.头文件2.初始化一维初始化//定义了一个名为num的存int数据的一维数组//定义了一个名为num的存double数据的一维数组//node是结构体类型1.指定长度和初始值的初始化//定义一个长度为n的数组，动态定义，不指定初值默认初值为0//所有的元素均为0。
C++ Vector (动态数组)
果光的博客
01-09 6238
简介 向量（Vector）是一个封装了动态大小数组的顺序容器。 向量是一个能够存放任意类型的动态数组。 C++ 中 Vector 的使用 头文件 #include <vector> 需要使用 std 命名空间 using namespace std; ...
c++ 之动态数组简单介绍
digitalkee的博客
06-05 3866
#include <iostream> #include <memory> using namespace std; int main() { typedef int ptr[109]; int *p = new ptr; for(int i = 0; i!= 109; ++i) p[i] = i; for(int i = 0; i!= 109;++i) cout << p[i] << endl; int n; cin >&gt.
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小嘤嘤怪学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值