C++中数组的动态分配以及内存分配的方式 ...

一、一维数组的动态创建

#include<iostream>
using namespace std;
int main()
{
    int *p, *q; //申请两个int 型的指针变量
    int n;
    p = new int[3]; //分配3个单位的int型内存空间，也就是3*4=12个字节

    for(int i = 0; i < 3; i++)
        p[i] = i + 1; //数组初始化

    for(int i = 0; i < 3; i++)
        cout << p[i] << " "; //输出

    cout << endl;
//
    cin >> n; //分配的大小也可以自己输入
    q = new int[n]; // n*4个字节

    for(int i = 0; i < n; i++)
        q[i] = i + 1; //数组初始化

    for(int i = 0; i < n; i++)
        cout << q[i] << " "; //输出
	cout<<endl;
	delete []p;
	delete []q; //注意最后别忘记释放内存
    system("pause");
    return 0;
}

运行结果：

1 2 3
5
1 2 3 4 5
请按任意键继续. . .

二、二维数组的动态创建

#include<iostream>
using namespace std;
int main()
{
    int **p;//定义指向指针的指针
    int m, n;// 维度的大小
    cin >> m >> n;//用户输入也可以是常量
    p = new int *[m];// 为行（第一维度）分配空间

    for(int i = 0; i < m; i++)
        p[i] = new int[n];//为第一行所在的列（第二维度）分配空间

    for(int i = 0; i < m; i++)
        for(int j = 0; j < n; j++)
            p[i][j] = 2;//赋初值

    for(int i = 0; i < m; i++)
    {
        for(int j = 0; j < n; j++)
            cout << p[i][j] << " ";//输出测试

        cout << endl;
    }
	for(int i=0;i<m;i++)// 释放内存，按每一行来释放
		delete []p[i];


    system("pause");
    return 0;
}

这里详说一下二维数组动态分配的过程（直接上图，从上往下看，每段语句对方下方的内存分配图）

三、内存分配的方式

1.堆与栈

    在程序中我们定义一个变量，它的值会被放入内存当中。如果我们没有申请动态分配的方式，它的值将直接放到栈中。在栈中的变量所属的内存大小一旦定义之后是无法被改变的，它们的产生与消亡也与变量定义的位置和存储方式有关。与栈对应的，堆是一种动态分配方式的内存。当我们申请使用动态分配方式去存储某个变量，那么这个 变量会被放入堆中，根据需要，这个变量的内存大小可以发生改变，内存的申请和销毁的时机则由编程都来操作。

2.关键字new与delete

    new是C++语言申请动态内存的关键字，形式如下：

int *p=new int;

这样，p指针就申请了动态方式，使用它在堆内申请的内存存储int 类型的值。

例1：动态分配空间

#include<iostream>
using namespace std;
int main()
{
    int *p1 = NULL;
    p1 = new int; // 申请动态分配内存(堆内存)
    *p1 = 12; // 动态分配的内存储存的内容变成了12
    cout << "p1内存的内容" << *p1 << "  p1所指向的地址" << p1 << endl;
    int *p2 = NULL;
    //p2=10;  这样赋值会报错，因为p2没有被分配内存
    int k;// 栈中分配的变量
    p2 = &k; // 分配栈内存，即把k所在的内存的地址赋给了p2
		   	//此时p2就指向了k所对应的内存
    *p2 = 11; // 此时就能赋值
    cout << "p2内存的内容" << *p2 << "  p2所指向的地址" << p2 << endl;
    system("pause");
    return 0;
}

运行结果：

p1内存的内容12  p1所指向的地址001DA400
p2内存的内容11  p2所指向的地址003AFE00
请按任意键继续. . .

例2：动态内存的销毁

#include<iostream>
using namespace std;
int *newPoint(int *p)
{
    int i = 1;
    p = new int ;//采用堆的方式为p分配空间
    *p = i;
    return p;//返回指向p的地址
}
int* Point(int *q)
{
    int i = 2;
    q = &i;//采用栈的方式为q分配空间
    return q;//返回指向q的地址
}
int main()
{
    int *p = NULL;
    int *q = NULL;
    p = newPoint(p);//p具有堆内存的地址
    cout << *p << endl;
    cout << *p << endl;
	delete p;//在被程序员手动释放前，p所指向的内存一直有效
	cout << *p << endl;//释放后
	cout<<endl<<endl;
	q=Point(q);//q具有栈内存的地址
	cout<<*q<<endl;//在被使用一次之后，程序自动将其释放掉
	cout<<*q<<endl;//释放后
    system("pause");
    return 0;
}

运行结果：

1
1
-572662307


2
1467401184
请按任意键继续. . .

3.内存安全

     指针是C++提供给我们的强大而灵活的工具，如何安全地使用它们对内存安全的操作是编程者必须要掌握的。当一块内存被销毁时，该区域不可复用。若有指针指向该区域，则需要将该指针置空(NULL)或者指向未被销毁的内存。

内存的销毁实质上是系统判定该内存不是编程人员正常使用的空间，系统也不会将它分配给别的任务。若擅自使用被销毁内存的指针更改内存的数据，很可能造成意想不到的结果。

例3.被销毁的内存

#include<iostream>
using namespace std;
int *Sum(int a, int b)
{
    int *ps = NULL;
    int c = a + b;
    ps = &c;//ps具有栈内存的地址
	return ps;
}
int main()
{
	int *p=NULL;
	int k1=3;
	int k2=5;
	p=Sum(k1,k2);
	cout<<"*p的值:"<<*p<<endl;//在被使用一次之后，程序自动将其释放掉
	cout<<"*p被释放之后的值:"<<*p<<endl;//释放之后的值
	cout<<"尝试修改*p"<<endl;
	*p=4;
	for(int i=0;i<3;i++)
		cout<<*p<<" ";


	system("pause");
	return 0;
}

运行结果：

*p的值:8
*p被释放之后的值:3733796
尝试修改*p
4 -858993460 -858993460 请按任意键继续. . .

    指针p从sum函数中得到了一个临时指针，该指针是指针ps的临时复制品，操作完成之后消失，它所保留的地址交给了p。在函数sum执行完毕后，该域使用的栈内存会被系统销毁甚至挪用。本程序尝试通过修改p继续使用，结果是系统会再次将其销毁。在某些场合下，该程序也许会引起内存报错，甚至造成多个程序崩溃。所以对于栈内存的指针一定要明白其何时销毁·，不再复用它。

此时相对应的另一个安全问题叫内存泄漏。在申请动态分配内存后，系统不会主动销毁该内存，需要编程者使用delete关键字通知系统销毁。如果不这样做，系统将浪费很多资源。销毁内存时，我们需要保留指向譔内存的指针。当没有指针指向一块未被销毁的内存时，些块内存犹如丢失了一般，我们称之为内存泄漏。

转载于:https://www.cnblogs.com/tolic/p/7142275.html