故事狗
故事狗

(Boolan)详解 C++ Operator new\delete、placement new\delete、Array new\delete

题目内容：

class Fruit{
int no;
double weight;
char key;
public:
void print() { }
virtual void process(){ }
};

class Apple: public Fruit{
int size;
char type;
public:
void save() { }
virtual void process(){ }
};

>
>
>为上周题目中的 Fruit和Apple 添加 构造函数与 析构函数， 并在构造函数与析构函数中打印控制台信息，
观察构造和析枸调用过程。然后为Apple类重载::operator new和 ::operator delete，在控制台打印信息，并观察调用结果。

#答案：
---
## 为了文章结构，我把代码放在文章后面，上面写的为代码片段，但为了方便查看运行结果，可以点击括号里面的链接（http://rextester.com/DOLN3287 ），进入后点击"run it"按钮就可以查看结果了
---
![父类和子类的关系](http://upload-images.jianshu.io/upload_images/5688965-16eec8112ecf6fa8.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

#### 1.子类对象创建时：会先创建父类对象，再创建子类对象（之前讲的装快递的故事）
#### 2.子-类对象销毁时：会先销毁子类对象，再销毁父类对象（之前讲的拆快递的故事）
#### 3.子类的大小 = 父类成员属性的大小 + 虚函数指针（不存在为0Byte） + 子类成员属性的大小
#### 4.子类的内存中包括父类对象（由内存地址相同可知）
#### 5.placement new和placement delete最好能成对出现，除非保证创建对象时不会产生异常
#### 6.placement delete只会在new对象时抛出异常时才会调用，并且是成对调用（形参列表相同）。
#### 7.placement new创建对象如果不抛出异常，不会调用placement delete，而是调用operator new。
#### 8.不成对的placement new和placement delete的时候，如果产生了异常，则无法已经申请的释放空间，会造成内存泄漏。
---
## 为了文章结构，我把代码放在文章后面，上面写的为代码片段，但为了方便查看运行结果，可以点击括号里面的链接（http://rextester.com/DOLN3287 ），进入后点击"run it"按钮就可以查看结果了
---
- Fruit和Apple的UML关系图
![UML](http://upload-images.jianshu.io/upload_images/5688965-e9b8100020917b94.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

### 测试1：*** 子父类的构造函数、析构函数的调用情况 ***
- Fruit构造函数（节选）

.....
class Fruit {
int no;
double weight;
char key;
public:
Fruit(int n = 0, double w = 0., char k = '0');//Fruit类构造函数
~Fruit();//Fruit的析构函数
....
void print();
};
....
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;
}
.....


- Apple构造函数（节选）

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(); //析构函数
void print();
........
};
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() {
//析构函数
printCalled("Apple", "~Apple()");
}
......
inline void Apple::print() {
//打印Apple的对象信息
Fruit::print();
cout << dec << "\nApple (" << size << ", " << type << ")\n"
<< "size = " << sizeof(*this) << ", " << "address = 0x" << hex << this << endl;
}


- 测试部分代码

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


- 结果
![在栈中创建对象](http://upload-images.jianshu.io/upload_images/5688965-8daca29432f24580.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 结论
1.子类对象创建时：会先创建父类对象，再创建子类对象（之前讲的装快递的故事）
2.子-类对象销毁时：会先销毁子类对象，再销毁父类对象（之前讲的拆快递的故事）
3.子类的大小 = 父类成员属性的大小 + 虚函数指针（不存在为0） + 子类成员属性的大小
4.子类的内存中包括父类对象（由内存地址相同可知）
---
### 测试二：测试operator new（无异常）
- Fruit代码

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);    //覆写的Fruit的operator new

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

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

};
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)");

//打印Fruit的对象情况
print();

}
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("Fruit", "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);
}


- Apple代码

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(); //析构函数
void* operator new(size_t size); //覆写的Apple的operator new
void operator delete(void* p); //覆写的Apple的operator delete

void print();
....

};
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() {
//析构函数
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)");
//this->print(); 错误提示：static不能调用non-static
//如果使用this指针在该处调用，会报错，operator new会自动转换为static的函数，仅用于分配空间，不会修改对象的内容
//换而言之，此时对象还尚未创建完成，仅仅分配了内存空间，所以this指针存在也是不可能的
return malloc(size);
}
inline void Apple::operator delete(void* p) {
//operator delete
printCalled("Apple", "void operator delete(void*)");
free(p);
}

- 测试代码

int main()
{
srand((unsigned) time(NULL));
.......

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

}

- 运行结果
![operator new测试](http://upload-images.jianshu.io/upload_images/5688965-0282d9149974ef38.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 结论 
1.operator new 中的参数std::size_t的实参的大小实际为该对象所需的大小
2.调用子类的operator new / operator delete时，并不会调用父类的operate new 
/ operator delete
---
###测试三：operator new创建对象产生异常时的处理
- Fruit代码：

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); //覆写的Fruit的operator new
void operator delete(void* p); //复写Fruit的operator delete
void operator delete(void* p, int type);
virtual void process() { }
void print();
};
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)");
//打印Fruit的对象情况
print();
}
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("Fruit", "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);
}

- Apple代码：

class Apple : public Fruit {
private:
int size;
char type;
public:
Apple(char test); //会抛出异常的构造函数
~Apple(); //析构函数
void* operator new(size_t size); //覆写的Apple的operator new
void operator delete(void* p, int type); //覆写的placement delete
void print();
void save() { }
virtual void process() { }
.......
};
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)");
//this->print(); 错误提示：static不能调用non-static
//如果使用this指针在该处调用，会报错，operator new会自动转换为static的函数，仅用于分配空间，不会修改对象的内容
//换而言之，此时对象还尚未创建完成，仅仅分配了内存空间，所以this指针存在也是不可能的
return malloc(size);
}
inline void Apple::operator delete(void* p) {
//operator delete
printCalled("Apple", "void operator delete(void*)");
free(p);
}

- 测试代码：

int main()
{
.....
Apple* pa1 = 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;
}
....
return 0;
}

- 运行结果：

![operator new的异常处理](http://upload-images.jianshu.io/upload_images/5688965-9ab8385849df21cf.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 结论：
1.调用operator new创建对象时，如果创建对象时产生异常，处理异常时`delete p;`，会调用`operator delete;`来释放申请的内存。
2.自定义异常类对象，会在异常处理完成后被销毁
---
### 测试四：placement new处理异常时调用情况
- Fruit代码

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); //覆写的Fruit的operator new
void operator delete(void* p); //复写Fruit的operator delete
void operator delete(void* p, int type);
virtual void process() { }
void print();
};
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)");
//打印Fruit的对象情况
print();
}
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("Fruit", "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);
}

- Apple代码

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, int type);  //覆写的Apple的第一个placement new
void operator delete(void* p, int type);    //覆写的placement delete
void print();
void save() {   }
virtual void process() {   }

};
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, int type) {
//placement new
printCalled("Apple placement new ", "void* operator new(size_t, int)");
return malloc(size);
}
inline void Apple::operator delete(void* p, int type) {
//placement delete
//为和此处不可以使用this指针来释放内存空间呢？
//this->print();尝试
//如果使用this指针在该出调用，会报错，operator delete会自动转换为static的函数，所以形参列表中必须传入一个指针
printCalled("Apple placement delete ", "void operator delete(void, int)");
free(p);
}
inline void Apple::print() {
//打印Apple的对象信息
Fruit::print();
cout << dec << "\nApple (" << size << ", " << type << ")\n"
<< "size = " << sizeof(this) << ", " << "address = 0x" << hex << this << endl;
}

- 测试代码

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

- 运行结果
![operator new的异常处理](http://upload-images.jianshu.io/upload_images/5688965-73c36459449b20ce.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)
- 结论
1.new对象的时候，如果使用的时候用的是placement new，则处理异常时，会调用对应形参列表的placement delete
---
### 测试五：placement new 创建对象时，不产生异常的情况
- Fruit代码

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); //覆写的Fruit的operator new
void operator delete(void* p); //复写Fruit的operator delete
void operator delete(void* p, int type);
virtual void process() { }
void print();
};
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)");
//打印Fruit的对象情况
print();
}
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("Fruit", "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);
}

- Apple代码

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(); //析构函数
void* operator new(size_t size); //覆写的Apple的operator new
void* operator new(size_t size, int type); //覆写的Apple的第一个placement new

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

.....
};
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() {
//析构函数
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)");
//this->print(); 错误提示：static不能调用non-static
//如果使用this指针在该处调用，会报错，operator new会自动转换为static的函数，仅用于分配空间，不会修改对象的内容
//换而言之，此时对象还尚未创建完成，仅仅分配了内存空间，所以this指针存在也是不可能的
return malloc(size);
}
inline void* Apple::operator new(size_t size, int type) {
//placement new
printCalled("Apple placement new ", "void* operator new(size_t, int)");
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 ", "void operator delete(void, int)");
free(p);
}
inline void Apple::print() {
//打印Apple的对象信息
Fruit::print();
cout << dec << "\nApple (" << size << ", " << type << ")\n"
<< "size = " << sizeof(this) << ", " << "address = 0x" << hex << this << endl;
}

- 测试代码

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

- 运行结果
![使用placement new创建对象不产生异常的结果](http://upload-images.jianshu.io/upload_images/5688965-b9f43aff7b4c1435.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 结论
1.调用placement new来创建对象时，如果没有产生异常，在delete时会调用operator delete
---
### 测试六：placement new 创建对象时，没有成对的placement delete的情况
- Fruit代码

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); //覆写的Fruit的operator new
void operator delete(void* p); //复写Fruit的operator delete
void operator delete(void* p, int type);
virtual void process() { }
void print();
};
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)");
//打印Fruit的对象情况
print();
}
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("Fruit", "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);
}

- Apple代码

class Apple : public Fruit {
private:
int size;
char type;
public:
Apple(char test); //会抛出异常的构造函数
~Apple(); //析构函数
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 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, char type) {
//placement new
cout << "size_t = " << size << endl;
printCalled("Apple placement new ", "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 ", "void operator delete(void, int)");
free(p);
}
inline void Apple::print() {
//打印Apple的对象信息
Fruit::print();
cout << dec << "\nApple (" << size << ", " << type << ")\n"
<< "size = " << sizeof(this) << ", " << "address = 0x" << hex << this << endl;
}

- 测试代码

int main(){

return 0;

}

- 运行结果
![不成对的placement new被调用还产生了异常](http://upload-images.jianshu.io/upload_images/5688965-7107f58840132473.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 结论
1.如果不存在成对的的placement new和placement delete，那么必须保证，** 创建对象时不会产生异常 **，否则就会造成内存泄漏。***如果存在产生异常的可能性，placement new和placement delete必须要成对出现。***
---
### 测试六：Array new测试
- Fruit代码

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); //覆写的Fruit的operator new
void operator delete(void* p); //复写Fruit的operator delete
void operator delete(void* p, int type);
virtual void process() { }
void print();
};
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)");
//打印Fruit的对象情况
print();
}
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("Fruit", "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);
}

- Apple代码

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的Array new
void operator delete[](void* p); //覆写的Array delete
void print();
.....
};
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() {
//析构函数
printCalled("Apple", "~Apple()");
}
inline void* Apple::operator new[](size_t size) {
//operator new[]
printCalled("Apple", "void* operator new(size_t)");
return malloc(size);
}
inline void Apple::operator delete[](void* p) {
//array delete
printCalled("Apple", "void operator delete");
free(p);
}
inline void Apple::print() {
//打印Apple的对象信息
Fruit::print();
cout << dec << "\nApple (" << size << ", " << type << ")\n"
<< "size = " << sizeof(*this) << ", " << "address = 0x" << hex << this << endl;
}

- 测试代码

int main(){
//数组测试
cout << s << "\n" "数组测试" << endl;
Apple* as1 = new Apple[2];
delete[] as1;
return 0;
}

- 运行结果
![Array new创建和销毁的情况](http://upload-images.jianshu.io/upload_images/5688965-39b53519113bacc2.png?imageMogr2/auto-orient/strip%7CimageView2/2/w/1240)

- 结论
1.对于数组创建，使用array new，会调用构造函数N次
2.对于数组的销毁，使用array delete，会调用其中对象的析构函数N次
---
- 全部代码

//************************
//************************
//*******自定义异常类******
//************************
//************************

ifndef TEST_EXCEPTION___

define TEST_EXCEPTION___

include

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

//#include "TestException.h"

include

include

include

include

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)");

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

return malloc(size);

}

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

inline void* Apple::operator new(size_t size, int type) {
//placement new
printCalled("Apple placement new ", "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 ", "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 ", "void operator delete(void*, int)");
free(p);
}

inline void Apple::operator delete[](void* p) {
//array delete
printCalled("Apple", "void operator delete");
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;

}

你可能感兴趣的:((Boolan)详解 C++ Operator new\delete、placement new\delete、Array new\delete)

  • c++ 的iostream 和 c++的stdio的区别和联系 黄卷青灯77 c++算法开发语言iostreamstdio
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
  • C#中使用split分割字符串 互联网打工人no1 c#
    1、用字符串分隔：usingSystem.Text.RegularExpressions;stringstr="aaajsbbbjsccc";string[]sArray=Regex.Split(str,"js",RegexOptions.IgnoreCase);foreach(stringiinsArray)Response.Write(i.ToString()+"");输出结果：aaabbbc
  • WPF中的ComboBox控件几种数据绑定的方式 互联网打工人no1 wpfc#
    一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 四章-32-点要素的聚合 彩云飘过
    本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
  • 【JS】执行时长(100分) |思路参考+代码解析（C++） l939035548 JS算法数据结构c++
    题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
  • 【华为OD技术面试真题 - 技术面】- python八股文真题题库（4) 算法大师 华为od面试python
    华为OD面试真题精选专栏：华为OD面试真题精选目录:2024华为OD面试手撕代码真题目录以及八股文真题目录文章目录华为OD面试真题精选**1.Python中的`with`**用途和功能自动资源管理示例：文件操作上下文管理协议示例代码工作流程解析优点2.\_\_new\_\_和**\_\_init\_\_**区别__new____init__区别总结3.**切片（Slicing）操作**基本切片语法
  • Python爬虫解析工具之xpath使用详解 eqa11 python爬虫开发语言
    文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
  • 基于CODESYS的多轴运动控制程序框架：逻辑与运动控制分离，快速开发灵活操作 GPJnCrbBdl python开发语言
    基于codesys开发的多轴运动控制程序框架，将逻辑与运动控制分离，将单轴控制封装成功能块，对该功能块的操作包含了所有的单轴控制（归零、点动、相对定位、绝对定位、设置当前位置、伺服模式切换等等）。程序框架由主程序按照状态调用分归零模式、手动模式、自动模式、故障模式，程序状态的跳转都已完成，只需要根据不同的工艺要求完成所需的动作即可。变量的声明、地址的规划都严格按照C++的标准定义，能帮助开发者快速
  • C++ | Leetcode C++题解之第409题最长回文串 Ddddddd_158 经验分享C++Leetcode题解
    题目：题解：classSolution{public:intlongestPalindrome(strings){unordered_mapcount;intans=0;for(charc:s)++count[c];for(autop:count){intv=p.second;ans+=v/2*2;if(v%2==1andans%2==0)++ans;}returnans;}};
  • C++菜鸟教程 - 从入门到精通 第二节 DreamByte c++
    一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
  • Linux MariaDB使用OpenSSL安装SSL证书 Meta39 MySQLOracleMariaDBLinuxWindowsssllinuxmariadb
    进入到证书存放目录，批量删除.pem证书警告：确保已经进入到证书存放目录find.-typef-iname\*.pem-delete查看是否安装OpenSSLopensslversion没有则安装yuminstallopensslopenssl-devel开启SSL编辑/etc/my.cnf文件（没有的话就创建，但是要注意，在/etc/my.cnf.d/server.cnf配置了datadir的，
  • Java面试题精选：消息队列(二) 芒果不是芒 Java面试题精选javakafka
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
  • (179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • (158)时序收敛---＞(08)时序收敛八 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛八（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (159)时序收敛---＞(09)时序收敛九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (160)时序收敛---＞(10)时序收敛十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (153)时序收敛---＞(03)时序收敛三 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）F
  • (121)DAC接口---＞(006)基于FPGA实现DAC8811接口 FPGA系统设计指南针 FPGA接口开发(项目实战)fpga开发FPGAIC
    1目录（a）FPGA简介（b）IC简介（c）Verilog简介（d）基于FPGA实现DAC8811接口（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电
  • FPGA复位专题---（3）上电复位？ FPGA系统设计指南针 FPGA系统设计(内训)fpga开发
    （3）上电复位？1目录（a）FPGA简介（b）Verilog简介（c）复位简介（d）上电复位？（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • ArrayList 源码解析 程序猿进阶 Java基础ArrayListListjava面试性能优化架构设计idea
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
  • (182)时序收敛---＞(32)时序收敛三二 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
    1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三二（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
  • C++ lambda闭包消除类成员变量 barbyQAQ c++c++java算法
    原文链接：https://blog.csdn.net/qq_51470638/article/details/142151502一、背景在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。拿到一个类，一看成员变量好几十个，就问你怕不怕？二、解决思路可以借助函数式编程思想，来消除一些不必要的类成员变量。三、实例举个例子：classClassA{public:...intfu
  • 2021 CCF 非专业级别软件能力认证第一轮（CSP-J1）入门级C++语言试题 （第三大题：完善程序 代码） mmz1207 c++csp
    最近有一段时间没更新了，在准备CSP考试，请大家见谅。（1）有n个人围成一个圈，依次标号0到n-1。从0号开始，依次0，1，0，1...交替报数，报到一的人离开，直至圈中剩最后一个人。求最后剩下的人的编号。#includeusingnamespacestd;intf[1000010];intmain(){intn;cin>>n;inti=0,cnt=0,p=0;while(cnt#includeu
  • 《 C++ 修炼全景指南：九 》打破编程瓶颈！掌握二叉搜索树的高效实现与技巧 Lenyiin C++修炼全景指南技术指南c++算法stl
    摘要本文详细探讨了二叉搜索树（BinarySearchTree,BST）的核心概念和技术细节，包括插入、查找、删除、遍历等基本操作，并结合实际代码演示了如何实现这些功能。文章深入分析了二叉搜索树的性能优势及其时间复杂度，同时介绍了前驱、后继的查找方法等高级功能。通过自定义实现的二叉搜索树类，读者能够掌握其实际应用，此外，文章还建议进一步扩展为平衡树（如AVL树、红黑树）以优化极端情况下的性能退化。
  • 20个新手学习c++必会的程序 输出*三角形、杨辉三角等（附代码） X_StarX c++学习算法大学生开发语言数据结构
    示例1:HelloWorld#includeusingnamespacestd;intmain(){coutusingnamespacestd;intmain(){inta=5;intb=10;intsum=a+b;coutusingnamespacestd;intfactorial(intn){if(nusingnamespacestd;voidprintFibonacci(intn){intt
  • C++八股 Petrichorzncu 八股总结c++开发语言
    这里写目录标题C++内存管理C++的构造函数，复制构造函数，和析构函数深复制与浅复制：构造函数和析构函数哪个能写成虚函数，为什么？C++数据结构内存排列结构体和类占用的内存：==虚函数和虚表的原理==虚函数虚表（Vtable）虚函数和虚表的实现细节==内存泄漏==指针的工作原理函数的传值和传址new和delete与malloc和freeC++内存区域划分C++11新特性C++常见新特性==智能指针
  • [Unity]在场景中随机生成不同位置且不重叠的物体 Bartender_Jill Graphics图形学笔记unity游戏引擎动画
    1.前言最近任务需要用到Unity在场景中随机生成物体，且这些物体不能重叠，简单记录一下。参考资料:Howtoensurethatspawnedtargetsdonotoverlap?2.结果与代码结果如下所示：代码如下所示：usingSystem.Collections.Generic;usingUnityEngine;namespaceAssets.Scripts{publicclassNew
  • java类加载顺序 3213213333332132 java
    package com.demo; /** * @Description 类加载顺序 * @author FuJianyong * 2015-2-6上午11:21:37 */ public class ClassLoaderSequence { String s1 = "成员属性"; static String s2 = "
  • Hibernate与mybitas的比较 BlueSkator sqlHibernate框架ibatisorm
    第一章     Hibernate与MyBatis Hibernate 是当前最流行的O/R mapping框架，它出身于sf.net，现在已经成为Jboss的一部分。 Mybatis 是另外一种优秀的O/R mapping框架。目前属于apache的一个子项目。 MyBatis 参考资料官网：http:
  • php多维数组排序以及实际工作中的应用 dcj3sjt126com PHPusortuasort
    自定义排序函数返回false或负数意味着第一个参数应该排在第二个参数的前面, 正数或true反之, 0相等usort不保存键名uasort 键名会保存下来uksort 排序是对键名进行的 <!doctype html> <html lang="en"> <head> <meta charset="utf-8&q
  • DOM改变字体大小 周华华 前端
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • c3p0的配置 g21121 c3p0
    c3p0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。c3p0的下载地址是：http://sourceforge.net/projects/c3p0/这里可以下载到c3p0最新版本。 以在spring中配置dataSource为例： <!-- spring加载资源文件 --> <bean name="prope
  • Java获取工程路径的几种方法 510888780 java
    第一种： File f = new File(this.getClass().getResource("/").getPath()); System.out.println(f); 结果: C:\Documents%20and%20Settings\Administrator\workspace\projectName\bin 获取当前类的所在工程路径; 如果不加“
  • 在类Unix系统下实现SSH免密码登录服务器 Harry642 免密ssh
    1.客户机     (1)执行ssh-keygen -t rsa -C "[email protected]"生成公钥，xxx为自定义大email地址     (2)执行scp ~/.ssh/id_rsa.pub root@xxxxxxxxx:/tmp将公钥拷贝到服务器上，xxx为服务器地址     (3)执行cat
  • Java新手入门的30个基本概念一 aijuans javajava 入门新手
    在我们学习Java的过程中,掌握其中的基本概念对我们的学习无论是J2SE,J2EE,J2ME都是很重要的,J2SE是Java的基础,所以有必要对其中的基本概念做以归纳,以便大家在以后的学习过程中更好的理解java的精髓,在此我总结了30条基本的概念。　　Java概述:　　目前Java主要应用于中间件的开发(middleware)---处理客户机于服务器之间的通信技术,早期的实践证明,Java不适合
  • Memcached for windows 简单介绍 antlove javaWebwindowscachememcached
    1. 安装memcached server a. 下载memcached-1.2.6-win32-bin.zip b. 解压缩，dos 窗口切换到 memcached.exe所在目录，运行memcached.exe -d install c.启动memcached Server,直接在dos窗口键入 net start "memcached Server&quo
  • 数据库对象的视图和索引 百合不是茶 索引oeacle数据库视图
      视图     视图是从一个表或视图导出的表，也可以是从多个表或视图导出的表。视图是一个虚表，数据库不对视图所对应的数据进行实际存储，只存储视图的定义，对视图的数据进行操作时,只能将字段定义为视图,不能将具体的数据定义为视图       为什么oracle需要视图;    &
  • Mockito(一) --入门篇 bijian1013 持续集成mockito单元测试
            Mockito是一个针对Java的mocking框架，它与EasyMock和jMock很相似，但是通过在执行后校验什么已经被调用，它消除了对期望 行为（expectations）的需要。其它的mocking库需要你在执行前记录期望行为（expectations），而这导致了丑陋的初始化代码。  &nb
  • 精通Oracle10编程SQL(5)SQL函数 bijian1013 oracle数据库plsql
    /* * SQL函数 */ --数字函数 --ABS(n):返回数字n的绝对值 declare v_abs number(6,2); begin v_abs:=abs(&no); dbms_output.put_line('绝对值：'||v_abs); end; --ACOS(n):返回数字n的反余弦值，输入值的范围是-1~1，输出值的单位为弧度
  • 【Log4j一】Log4j总体介绍 bit1129 log4j
    Log4j组件：Logger、Appender、Layout   Log4j核心包含三个组件：logger、appender和layout。这三个组件协作提供日志功能： 日志的输出目标 日志的输出格式 日志的输出级别(是否抑制日志的输出)  logger继承特性 A logger is said to be an ancestor of anothe
  • Java IO笔记 白糖_ java
    public static void main(String[] args) throws IOException { //输入流 InputStream in = Test.class.getResourceAsStream("/test"); InputStreamReader isr = new InputStreamReader(in); Bu
  • Docker 监控 ronin47 docker监控
             目前项目内部署了docker，于是涉及到关于监控的事情，参考一些经典实例以及一些自己的想法，总结一下思路。 1、关于监控的内容 监控宿主机本身 监控宿主机本身还是比较简单的，同其他服务器监控类似，对cpu、network、io、disk等做通用的检查，这里不再细说。 额外的，因为是docker的
  • java-顺时针打印图形 bylijinnan java
    一个画图程序 要求打印出： 1.int i=5; 2.1 2 3 4 5 3.16 17 18 19 6 4.15 24 25 20 7 5.14 23 22 21 8 6.13 12 11 10 9 7. 8.int i=6 9.1 2 3 4 5 6 10.20 21 22 23 24 7 11.19
  • 关于iReport汉化版强制使用英文的配置方法 Kai_Ge iReport汉化英文版
    对于那些具有强迫症的工程师来说，软件汉化固然好用，但是汉化不完整却极为头疼，本方法针对iReport汉化不完整的情况，强制使用英文版，方法如下： 在 iReport 安装路径下的 etc/ireport.conf 里增加红色部分启动参数，即可变为英文版。   # ${HOME} will be replaced by user home directory accordin
  • [并行计算]论宇宙的可计算性 comsci 并行计算
          现在我们知道,一个涡旋系统具有并行计算能力.按照自然运动理论,这个系统也同时具有存储能力,同时具备计算和存储能力的系统,在某种条件下一般都会产生意识......       那么,这种概念让我们推论出一个结论     &nb
  • 用OpenGL实现无限循环的coverflow dai_lm androidcoverflow
    网上找了很久，都是用Gallery实现的，效果不是很满意，结果发现这个用OpenGL实现的，稍微修改了一下源码，实现了无限循环功能 源码地址： https://github.com/jackfengji/glcoverflow public class CoverFlowOpenGL extends GLSurfaceView implements GLSurfaceV
  • JAVA数据计算的几个解决方案1 datamachine javaHibernate计算
    老大丢过来的软件跑了10天，摸到点门道，正好跟以前攒的私房有关联，整理存档。 -----------------------------华丽的分割线-------------------------------------     数据计算层是指介于数据存储和应用程序之间，负责计算数据存储层的数据，并将计算结果返回应用程序的层次。J  &nbs
  • 简单的用户授权系统,利用给user表添加一个字段标识管理员的方式 dcj3sjt126com yii
    怎么创建一个简单的(非 RBAC)用户授权系统 通过查看论坛，我发现这是一个常见的问题，所以我决定写这篇文章。 本文只包括授权系统.假设你已经知道怎么创建身份验证系统(登录)。 数据库 首先在 user 表创建一个新的字段(integer 类型),字段名 'accessLevel',它定义了用户的访问权限 扩展 CWebUser 类 在配置文件(一般为 protecte
  • 未选之路 dcj3sjt126com 诗
    作者:罗伯特*费罗斯特   黄色的树林里分出两条路, 可惜我不能同时去涉足, 我在那路口久久伫立, 我向着一条路极目望去, 直到它消失在丛林深处.   但我却选了另外一条路, 它荒草萋萋,十分幽寂; 显得更诱人,更美丽, 虽然在这两条小路上, 都很少留下旅人的足迹.   那天清晨落叶满地, 两条路都未见脚印痕迹. 呵,留下一条路等改日再
  • Java处理15位身份证变18位 蕃薯耀 18位身份证变15位15位身份证变18位身份证转换
      15位身份证变18位，18位身份证变15位 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
  • SpringMVC4零配置--应用上下文配置【AppConfig】 hanqunfeng springmvc4
    从spring3.0开始，Spring将JavaConfig整合到核心模块，普通的POJO只需要标注@Configuration注解，就可以成为spring配置类，并通过在方法上标注@Bean注解的方式注入bean。   Xml配置和Java类配置对比如下： applicationContext-AppConfig.xml   <!-- 激活自动代理功能 参看：
  • Android中webview跟JAVASCRIPT中的交互 jackyrong JavaScripthtmlandroid脚本
      在android的应用程序中,可以直接调用webview中的javascript代码,而webview中的javascript代码,也可以去调用ANDROID应用程序(也就是JAVA部分的代码).下面举例说明之: 1 JAVASCRIPT脚本调用android程序    要在webview中,调用addJavascriptInterface(OBJ,int
  • 8个最佳Web开发资源推荐 lampcy 编程Web程序员
    Web开发对程序员来说是一项较为复杂的工作，程序员需要快速地满足用户需求。如今很多的在线资源可以给程序员提供帮助，比如指导手册、在线课程和一些参考资料，而且这些资源基本都是免费和适合初学者的。无论你是需要选择一门新的编程语言，或是了解最新的标准，还是需要从其他地方找到一些灵感，我们这里为你整理了一些很好的Web开发资源，帮助你更成功地进行Web开发。 这里列出10个最佳Web开发资源，它们都是受
  • 架构师之面试------jdk的hashMap实现 nannan408 HashMap
    1.前言。   如题。 2.详述。   (1)hashMap算法就是数组链表。数组存放的元素是键值对。jdk通过移位算法（其实也就是简单的加乘算法），如下代码来生成数组下标(生成后indexFor一下就成下标了）。 static int hash(int h) { h ^= (h >>> 20) ^ (h >>>
  • html禁止清除input文本输入缓存 Rainbow702 html缓存input输入框change
    多数浏览器默认会缓存input的值，只有使用ctl+F5强制刷新的才可以清除缓存记录。 如果不想让浏览器缓存input的值，有2种方法： 方法一： 在不想使用缓存的input中添加 autocomplete="off";  <input type="text" autocomplete="off" n
  • POJO和JavaBean的区别和联系 tjmljw POJOjava beans
    POJO 和JavaBean是我们常见的两个关键字，一般容易混淆，POJO全称是Plain Ordinary Java Object / Pure Old Java Object，中文可以翻译成：普通Java类，具有一部分getter/setter方法的那种类就可以称作POJO，但是JavaBean则比 POJO复杂很多， Java Bean 是可复用的组件，对 Java Bean 并没有严格的规
  • java中单例的五种写法 liuxiaoling java单例
    /** * 单例模式的五种写法： * 1、懒汉 * 2、恶汉 * 3、静态内部类 * 4、枚举 * 5、双重校验锁 */ /** * 五、 双重校验锁，在当前的内存模型中无效 */ class LockSingleton { private volatile static LockSingleton singleton; pri
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他