C++ Primer Plus书之--C++内存分配, new动态分配内存, 定位new运算符

先看一个小知识点:

函数和链接性

C++不允许在一个函数中定义另外一个函数, 所有的函数存储持续性都是自动为静态的, 即在整个程序执行期间都一直存在. 默认情况下函数的链接性为外部的, 即可以在文件间共享. 要让程序在另一个文件中查找函数, 该文件必须作为程序的组成部分被编译, 或者是又链接程序搜索的库文件. 还可以使用static关键字将函数的链接性设置为内部的, 使之只能在一个文件中使用, 必须同时在原型和函数定义中使用该关键字例如:

static int private(double x);
...
static int private(double x)
{
    ...
}

 但定义规则也适用于非内联函数, 因此对于每个非内联函数, 程序只能包含一个定义. 对于链接性为外部的函数来说, 在多文件程序中, 只能有一个文件包含该函数的定义, 但使用该函数的每个文件都应包含其函数原型.

假设在程序的某个文件中调用一个函数, 如果该函数原型指出该函数是静态的, 则编译器只在该文件中查找函数定义; 否则编译器将在所有程序文件中查找, 如果找到两个定义, 编译器就会报错, 因为每个外部函数只能有一个定义. 如果程序文件中没有找到, 编译器将在库中查找, 这意味着如果定义了一个与库函数同名的函数, 编译器将使用程序员定义的版本, 而不是库函数.

存储方案和动态分配

通常编译器使用三块独立的内存:

1.用于静态变量的

2.用于自动变量的

3.用于动态存储

虽然存储方案概念不适用于动态内存, 但适用于用来跟踪动态内存的自动和静态指针变量, 例如, 假设在一个函数中包含了下面的语句:

float* p_fees = new float[20];

由new分配的80个字节的内存将一直保留在内存当中, 直到使用delete运算符将其释放. 但当包含该声明的语句块执行完毕时, p_fees指针将消失. 如果希望另一个函数能够使用这80个字节中的内容, 则必须将其地址传递或返回给该函数. 另一方面, 如果将p_fees的链接性声明为外部的, 则文件中位于该声明后的所有函数都可以使用它, 另外通过在另一个文件中使用下述声明, 便可在其中使用该指针:

extern float* p_fees;

使用new运算符初始化:

// int型指针初始化为6
int* pi = new int(6);
// double型指针初始化为99.99
double * pd = new double(99.99);

// 结构体初始化:
struct where
{
    double x;
    double y;
    double z;
};
where* one = new where {2.5, 3.6, 1.2};
// 数组初始化
int* ar = new int[4]{1, 2, 3, 4};

// 单值变量初始化
int* pin = new int{10};
double * pdouble = new double{99.99};

 

定位new运算符

new除了负责在堆内存中找到一个足矣能够满足要求的内存块外, 还有另一种变体, 被称为定位(placement)new运算符, 它能够制定要使用的位置. 我们可以使用这种特性来处理需要通过特定地址进行访问的硬件或在特定位置创建对象, 例如:

// 如果使用new的定位符功能需要引入new头文件
#include <new>
// 定义一个结构体
struct chaff
{
    char dross[20];
    int slag;
};
// 两个数组
char buffer1[50];
char buffer2[500];

int main() 
{
    // 定义几个指针
    chaff *p1, *p2;
    int *p3, *p4;
    // 普通的用new申请空间
    // 在堆中new一个结构体
    p1 = new chaff;
    // 在堆中申请一个int型数组
    p3 = new int[20];
    
    // 使用new的定位运算符功能
    // 在buffer1的空间里 构建一个结构体
    p2 = new (buffer1) chaff;
    // 在buffer2的空间里, 构建一个int数组
    p4 = new (buffer2) int[20];
    ...
}

来看一个完整的例子:
// new的定位运算符功能
#include <iostream>
// 要使用new定位运算符功能, 必须包含头文件
#include <new>
using namespace std;

const int BUF = 512;
const int N = 5;
char buffer[BUF];

int main()
{
    double *pd1, *pd2;
    int i;
    cout << "Calling new and placement new: " << endl;
    // 在堆内存中创建了一个double数组
    pd1 = new double[N];
    // new定位运算符, 在buffer空间内创建了一个 double型数组
    pd2 = new (buffer) double[N];
    // 初始化两个数组
    for(i = 0; i < N; i++)
    {
        pd2[i] = pd1[i] = 1000 + 20.0 * i;
    }
    cout << "Memory addresses : " << endl;
    // pd1是double指针直接就能打印地址, 而buffer是char指针直接打印会打印字符串, 因此需要(void *)对buffer进行强制转换
    cout << "heap: " << pd1 << " static : " << (void *)buffer << endl;
    cout << "Memory contents: " << endl;
    for(i = 0; i < N; i++)
    {
        cout << pd1[i] << " at " << &pd1[i] << ", ";
        cout << pd2[i] << " at " << &pd2[i] << endl;
    }
    
    cout << "Calling new and placement new a second time: " << endl;
    double *pd3, *pd4;
    // 这个是在堆中新分配的内存
    pd3 = new double[N];
    // 这个使用的还是buffer的内存区域
    pd4 = new (buffer) double[N];
    // 初始化两个数组
    for(i = 0; i < N - 1; i++)
    {
        pd2[i] = pd1[i] = 1000 + 40.0 * i;
    }
    cout << "Memory contents: " << endl;
    for(i = 0; i < N; i++)
    {
        cout << pd3[i] << " at " << &pd3[i] << ", ";
        cout << pd4[i] << " at " << &pd4[i] << endl;
    }
    
    cout << "Calling new and placement new a third time: " << endl;
    // 释放资源
    delete[] pd1;
    // 重新使用pd1
    pd1 = new double[N];
    // 这里跳过了N * sizeof(double)个字节, 为了不再从buffer的起始位置开始分配内存
    pd2 = new (buffer + N * sizeof(double)) double[N];
    for(i = 0; i < N; i++)
    {
        pd2[i] = pd1[i] = 1000 + 60.0 * i;
    }
     cout << "Memory contents: " << endl;
    for(i = 0; i < N; i++)
    {
        cout << pd1[i] << " at " << &pd1[i] << ", ";
        cout << pd2[i] << " at " << &pd2[i] << endl;
    }
    // 注意这里只能使用delete释放常规new运算符分配的堆内存
    // 而不能使用delete释放buffer指定的静态内存(是new的定位运算符分配的内存)
    // 如果buffer是new常规运算符创建的就可以使用delete释放内存
    delete[] pd1;
    delete[] pd3;
    return 0;
}

程序运行结果为:

值得注意的地方都写的有注释

关于为什么不使用delete释放pd2, pd4, 请看注释

 

 

new定位运算符用于类

// new定位运算符用于类对象
#include <iostream>
#include <string>
#include <new>

using namespace std;
const int BUF = 512;

class JustTesting
{
private:
	string words;
	int number;
public:
	// 带默认参数的构造函数
	JustTesting(const string & s = "Default", int n = 0)
	{
		words = s;
		number = n;
		cout << words << " constructed " << endl;
	}
	~JustTesting()
	{
		cout << words << " destroyed " << endl;
	}
	void Show() const
	{
		cout << words << ", number : " << number << endl;
	}
};

int main()
{
	char * buffer = new char[BUF];
	JustTesting *pc1, *pc2;
	
	// new定位运算符, 在buffer的内存空间中存储JustTesting对象
	pc1 = new (buffer) JustTesting;
	pc2 = new JustTesting("Heap1", 20);
	
	cout << "Memory bolck addresses : " << endl << "buffer: " << (void *)buffer << ", heap: " << pc2 << endl;
	
	cout << "Memory contents: " << endl;
	cout << pc1 << ":";
	pc1->Show();
	cout << pc2 << ":";
	(*pc2).Show();
	
	JustTesting *pc3, *pc4;
	// 为避免把pc1指向内存中的内容给覆盖掉, 需要后移地址
	pc3 = new(buffer + sizeof(JustTesting)) JustTesting("Better", 6);
	pc4 = new JustTesting("Heap2", 10);
	cout << "Memory contents: " << endl;
	cout << pc3 << ":";
	pc3->Show();
	cout << pc4 << ":";
	(*pc4).Show();
	
	// 释放内存, 堆内存
	delete pc2;
	delete pc4;
	
	// 要想调用buffer空间存储的对象的析构函数, 只能显示效用
	pc3->~JustTesting();
	pc1->~JustTesting();
	delete[] buffer;
	cout << "Done" << endl;
	return 0;
}

程序输出结果为: