Fruit_, C++ (gcc) - rextester

Language: Layout:

//************************
//************************
//*******自定义异常类******
//************************
//************************
#ifndef TEST_EXCEPTION___
#define TEST_EXCEPTION___
#include <iostream>
using namespace std;

//自定义异常
class TestException{
public:
	//异常构造函数
	TestException() {
		cout << "TestException() has been called" << endl;
	}
	//异常的析构函数
	~TestException() {
		cout << "~TestException() has been called" << endl;
	}

};

//打印异常信息
inline ostream& operator<< (ostream &o, const TestException &e) {
	o << "TestException\n";
	return o;
}

#endif // !TEST_EXCEPTION___

//************************
//************************
//*******Fruit 和Apple****
//************************
//************************

#ifndef __FRUIT__EL___
#define __FRUIT__EL___

#include <iostream>
//#include "TestException.h"
#include <string>
#include <iomanip>
#include <ctime>
#include <cstdlib>

string operator*(string, const int);
inline void printCalled(const string, const string);
extern const string x = "*";

class Fruit {
	int no;
	double weight;
	char key;
public:
	Fruit(int n = 0, double w = 0., char k = '0');//Fruit类构造函数
	~Fruit();//Fruit的析构函数

void* operator new(size_t size);

void operator delete(void* p);	//复写Fruit的operator delete
	void operator delete(void* p, int type);

virtual void process() {   }
	void print();
};

class Apple : public Fruit {
private:
	int size;
	char type;
public:
	Apple(int n = 0, double w = 0, char k = '0', int s = 0, char t = '0');	//构造函数
	Apple(char test);	//会抛出异常的构造函数
	~Apple();			//析构函数

void* operator new(size_t size);	//覆写的Apple的operator new
	void* operator new[](size_t size);	//覆写的Apple的Array new
	void* operator new(size_t size, int type);	//覆写的Apple的第一个placement new
	void* operator new(size_t size, char type);	//覆写的Apple的第二个placement new（这个一个没有配对的placement delete，为了方便测试内存泄漏情况）

void operator delete(void* p);		//覆写的Apple的operator delete
	void operator delete(void* p, int type);	//覆写的placement delete

void operator delete[](void* p);	//覆写的Array delete

void print();
	void save() {   }
	virtual void process() {   }
};

using namespace std;
inline Fruit::Fruit(int n, double w, char k) :no(n), weight(w), key(k) {
	//如果为无参调用，随机生成Fruit中间的参数
	if (n == 0 && w == 0. && k == '0') {
		no = rand() % 100;
		weight = rand() / RAND_MAX;
		key = rand() % 26 + 97;
	}
	//Fruit的构造函数调用打印
	printCalled("Fruit", "Fruit(int, double, char)");
	
}
inline Fruit::~Fruit() {
	//析构函数调用时，输出结果
	cout << dec << "\nThe object Fruit(" << no << ", " << weight << ", " << key << ") has been deconstructed" << endl;
}

inline void Fruit::print() {
	//对象内容打印
	cout << dec 
		<< "Fruit(" << no << ", " << weight << ", " << key << ")\n"
		<< "size = " << sizeof(*this) << ", " << "address = 0x" << hex << this << endl;
}

inline void* Fruit::operator new(size_t size) {
	//operator new
	cout << "size_t = " << size << endl;
	printCalled("Apple", "void* operator new(size_t)");

//this->print();	错误提示：static不能调用non-static
	//如果使用this指针在该处调用，会报错，operator new会自动转换为static的函数，仅用于分配空间，不会修改对象的内容
	//换而言之，此时对象还尚未创建完成，仅仅分配了内存空间，所以this指针存在也是不可能的

return malloc(size);
}

inline void Fruit::operator delete(void* p) {
	//operator delete被调用时打印调用信息
	printCalled("Fruit", "void* operator delete(void*)");
	//释放内存
	free(p);
}

inline void Fruit::operator delete(void* p, int type) {
	//placement delete 被调用时打印调用信息
	printCalled("Fruit", "void* operator delete(void*, int)");
	//释放内存
	free(p);
}

inline Apple::Apple(int n, double w, char k, int s, char t) :Fruit(n, w, k), size(s), type(t) {
	//无参调用Apple的构造函数，会随机生成内容
	if (n == 0 && w == 0. && k == '0' && s == 0 && t == '0') {
		size = rand() % 100;
		type = rand() % 26 + 97;
	}
	//构造函数被调用，打印信息
	printCalled("Apple", "Apple(int, double, char, int, char)");
	//打印对象信息
	print();
}

inline Apple::Apple(char test) {
	//有参构造函数调用时打印信息
	printCalled("Apple", "Apple(int)");
	//抛出自定义异常
	throw TestException();
}

inline Apple::~Apple() {
	//析构函数
	printCalled("Apple", "~Apple()");
}

inline void* Apple::operator new(size_t size) {
	//operator new
	cout << "size_t = " << size << endl;
	printCalled("Apple", "void* operator new(size_t)");

return malloc(size);
}

inline void* Apple::operator new[](size_t size) {
	//operator new[]
	printCalled("Apple", "void* operator new[](size_t)");
	return malloc(size);
}

inline void* Apple::operator new(size_t size, int type) {
	//placement new 
	printCalled("Apple placement new  <int>", "void* operator new(size_t, int)");
	return malloc(size);
}

inline void* Apple::operator new(size_t size, char type) {
	//placement new
	cout << "size_t = " << size << endl;
	printCalled("Apple placement new <char>", "void* operator new(size_t, char)");

return malloc(size);
}

inline void Apple::operator delete(void* p) {
	//operator delete
	printCalled("Apple", "void operator delete(void*)");
	free(p);
}

inline void Apple::operator delete(void* p, int type) {
	//placement delete
	//为和此处不可以使用this指针来释放内存空间呢？
	//this->print();尝试
	//如果使用this指针在该出调用，会报错，operator delete会自动转换为static的函数，所以形参列表中必须传入一个指针
	printCalled("Apple placement delete <int>", "void operator delete(void*, int)");
	free(p);
}

inline 	void Apple::operator delete[](void* p) {
	//array delete
	printCalled("Apple", "void operator delete[](void*)");
	free(p);
}

inline void Apple::print() {
	//打印Apple的对象信息
	Fruit::print();
	cout << dec << "\nApple (" << size << ", " << type << ")\n" 
		<< "size = " << sizeof(*this) << ", " << "address = 0x" << hex << this << endl;
}

inline string operator*(string content,const int count) {
	string c = content;
	for (int i = 0; i < count; i++) {
		content += c;
	}
	return content;
}

inline void printCalled(const string scope, const string functionName) {
	cout << "\n(" << scope << ")    "<<  functionName << " has been called\n";
}
#endif // !__FRUIT__EL___

const string s = "\n\n" + x * 50 + "\n\n";
int main()
{
	srand((unsigned) time(NULL));
	//在栈里面创建对象的测试
	cout << s << "\n" "在栈里面创建对象的测试" << endl;
	Apple();//临时对象，生命周期仅在这一句，执行完就会弹出栈

cout << x * 50 << "\n\n\n";

//在堆里面创建对象的测试
	cout << s << "\n" "通过普通的new，在堆里面创建对象的测试" << endl;
	Apple* pa = new Apple();
	delete pa;

Apple* pa1 = NULL, *pa2 = NULL;

//测试调用抛出异常的构造函数，重写了operator new，检测抛出异常后，会调用哪个delete 
	cout << s << "\n" "测试调用抛出异常的构造函数，重写了operator new，检测抛出异常后，会调用哪个delete " << endl;
	try {
		pa1 = new Apple('1');
	}
	catch (TestException &e) {
		cout << "\nexception catched\n" << e;
		if(pa1)
			delete pa1;
	}
	
	//测试抛出异常的构造函数，重写并调用了placement new,检测抛出异常后，会调用哪个delete
	cout << s << "\n" "测试抛出异常的构造函数，重写并调用了placement new,检测抛出异常后，会调用哪个delete" << endl;
	try {
		pa2 = new (1)Apple('1');
	}
	catch (TestException &e) {
		cout << "\nexception catched\n" << e;
		if (pa2)
			delete pa2;
	}

//测试调用一个不成对的placement new，会调用那个delete
	cout << s << "\n" "测试调用一个不成对的placement new,检测抛出异常后，会调用哪个delete" << endl;
	try {
		pa2 = new ('1')Apple('1');	
	}
	catch (TestException &e) {
		cout << "\nexception catched\n" << e;
		if (pa2)
			delete pa2;
	}

//测试调用正常的构造函数的过程，使用的是重写的operator new，检测会调用那个delete
	cout << s << "\n""测试调用正常的构造函数的过程，使用的是重写的operator new，检测会调用那个delete" << endl;
	Apple* pa3 = new(1)Apple();
	delete pa3;

//数组测试
	cout << s << "\n" "数组测试" << endl;
	Apple* as1 = new Apple[2];
	delete[] as1;

return 0;
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.72 sec, absolute running time: 0.14 sec, cpu time: 0 sec, memory peak: 3 Mb, absolute service time: 0,87 sec