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

最新推荐文章于 2022-03-08 15:38:00 发布
最新推荐文章于 2022-03-08 15:38:00 发布
阅读量360 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Toonle/article/details/77511915
版权

题目内容：

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"按钮就可以查看结果了


父类和子类的关系
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

测试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();//临时对象，生命周期仅在这一句，执行完就会弹出栈
.....
}
.....

  • 结果


    在栈中创建对象

  • 结论
    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测试

  • 结论
    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的异常处理
  • 结论：
    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  <int>", "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 <int>", "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的异常处理
  • 结论
    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  <int>", "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 <int>", "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创建对象不产生异常的结果

  • 结论
    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 <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::print() {
  //打印Apple的对象信息
  Fruit::print();
  cout << dec << "\nApple (" << size << ", " << type << ")\n" 
      << "size = " << sizeof(*this) << ", " << "address = 0x" << hex << this << endl;
}

  • 测试代码

    int main(){

  return 0;
}

  • 运行结果


    不成对的placement new被调用还产生了异常

  • 结论
    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[](void*)");
  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创建和销毁的情况

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

  • 全部代码
//************************
//************************
//*******自定义异常类******
//************************
//************************
#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)");

    //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[](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;
}
Toonle
关注
(Boolan) C++ STL与泛型编程——容器1
Toonle的专栏
08-23 660
STL标准库是开发中的利器，也是开发的宝库。 这次的源码分析主要以GNU C++的2.9和4.9版本为例，因为4.9之后代码重构，核心部分发生了巨大的变化，再次分别分析一下。 以GCC为例的标准库位置： ....\x.x.x\include\c++\ 本地的目录 对于2.9和4.9最大的差别其实就是，2.9主要采用了泛型编程的思想，4.9引入了大量的面向对象编程的思想。 OOP（Object-O
Boolan C++ 笔记 七
Zarathustra的博客
08-31 341
OOP(Object-Oriented programming) VS. GP(Generic Programming) OOP企图将datas 和 methods 关联在一起 数据放在类里面,操作这些数据的函数也放在类里面 template<class T,class Alloc = alloc> class list{ ... void sort(); }为什么list不能使用::sort()
关于C++ 的operator new、 operator new[]、operator delete、operator delete[]、placement new、placement delete
qq_31984717的博客
01-03 728
1.operator new 与 new operator的区别 答：我们经常会使用new来动态分配一个对象，而使用的new就是new运算符。那么new一个对象后面会发生什么事呢？      ① 调用operator new函数申请一段内存（大小刚好就是你要new的那个对象的大小，那个大小会作为参数传给函数，如果是operator new[]则是所有对象总共的大小）      ② 然后编译器...
c++ - placement operator new() and the operator delete()
iteye_13882的博客
09-23 116
A class member operator new() can be overloaded. Provided that each delcaration has a unique paramter list. The first parameter of any class operator new() must always be a parameter of type size_t, f...
C/C++编程：写了placement new也要写placement delete
OceanStar的博客
05-13 327
对于： Widget *pw = new Widget ; 共有两个函数被调用：一个是用以分配的operator new，一个是Widget的默认构造函数 假设第一个函数调用成功，第二个函数抛出异常-----第一步的内存分配所得的内存必须归还，否则内存泄漏。此时，客户没有能力归还内存，因为如果Widget构造函数抛出异常，pw尚未被赋值，客户手上也没有指针指向应该被归还的内存。取消第一步并恢复到原来的责任因此落在C++运行期系统上。 运行期系统会调用步骤一所调用的operator new的响应的opera
C++ operator new ,operator delete,placement new
We_are_family678的博客
03-22 299
一、 operator new的三种形式：operator new有三种形式：throwing (1)void* operator new (std::size_t size) throw (std::bad_alloc); nothrow (2)void* operator new (std::size_t size, const std::nothrow_t&amp; nothrow_valu...
new、placement new、delete、placement delete
finewind的专栏
09-12 773
new表达式 c++提供了new关键字和delete关键字，分别用于申请和释放内存空间，其中new表达式的语法如下： new new-type-id (optional-initializer-expression-list) new表达式做两件事情： 在堆(heap)上申请一块空间，大小等于sizeof(new-type-id) 在申请的空间上构建对象，即调用对象的构造函数 new...
C++中的三大函数和操作符重载(Boolan)
12-26
如果对象是通过new操作符创建的，则通过delete操作符调用析构函数。 复制构造函数： 形如foo_t(const foo_t& foo)，以下情况复制构造函数均会被调用： 当对象按值返回时候(returned by value) 调用按值传参的函数...
(Boolan) C++ STL与泛型编程
Toonle的专栏
08-23 435
关于STL的话题已经探讨了好几个篇了，今天来讨论一下剩下的一些内容吧 一个万用的hash function 使用以Hash Table为底层的容器，比如unordered_map（hash_map），在使用个过程中，需要有计算hash code的方法来计算出元素在hashtable中的具体位置。那么对于自定义类型来说，需要指定对应的Hash Function，只有这样才能在使用的过程，系统找到对应
operator new之placement new/delete
蔚蓝的天空Tom
07-13 273
如果operator new接受的参数除了一定会有的那个std::size_t 之外还有其他，这便是所谓的placement new   众多placement new版本中特别有用的一个是“接受一个指针指向对象该被构造之处”，如下所示： void* operator new(std::size_t size, void* pMemory) throw();   此版本的operato
placement new和placement delete
Ron的专栏
07-04 716
对于Widget*pw = new Widget;共有两个函数被调用；一个是用以分配内存的operatornew，一个是Widget的默认构造函数。   假设第一个函数调用成功，第二个函数却抛出异常。步骤一的内存分配所得必须取消并恢复旧观，否则会造成内存泄露。在这个时候，客户没有能力归还内存，因为如果Widget构造函数抛出异常，pw尚未被赋值，客户手上也就没有指针指向被归还的内存。取消步骤一并
写了placement new也要写placement delete——条款52
yj_android_develop的博客
10-03 305
placementnew和placementdelete并非C++兽栏中最常见的动物，如果你不熟悉它们，不要感到挫折或忧虑。回忆条款16和17，当你写一个new表达式像这样： Widget* pw = new Widget; 共有两个函数被调用：一个是用以分配内存的operatornew，一个是Widget的default构造函数。 假设其中第一个函数调用成功，第二个函数却抛出异常。既然这样，步骤一的内存分配所得必须取消并恢复旧观，否则会造成内存泄漏。在这个时候...
关于new delete和placement new，placement delete
Android's Blog
05-10 1795
问题： 在看stl源码的时候，发现new 还可以这么调用： T* tmp = (T*)(::operator new((size_t)(sizeof(T) * n))); 这个调用很类似于malloc这样的形式，而且参数是以字节为主的，这和我平时使用的new 不一样的，那么::operator new是不是更加底层的函数，也就是上层的new其实是通过调用这个函数来申请空间的呢？ 解答：
8.new,operator new的区别，placement new,delete,operator delete的区别
小小酥的博客
08-23 127
new,placement new,delete,operator delete new和delete是一对 new其实分两步， operator new//分配内存 constructor//调用对象的构造函数 delete也是两步 destroy //析构 operator delete//释放内存 注意：如果只用new，那么也只用delete。 如果分两步使用new，那也分两步使用delete。 placement new其实就是new的更可灵活的版本，接收两个参数，一个是特地的地址空间
c++ new操作符（new operator）、operator new、placement new 、operator new[] 及相对应的delete 操作符、operator delete
baidu_16370559的博客
03-08 2332
一.new new operator就是new操作符，不能被重载，假如A是一个类，那么A * a=new A;实际上执行如下3个过程。 （1）调用operator new分配内存，operator new (sizeof(A)) （2）调用构造函数生成类对象，A::A() （3）返回相应指针 事实上，分配内存这一操作就是由operator new(size_t)来完成的，如果类A重载了operator new，那么将调用A::operator new(size_t )，否则调用全局:...
c++杂记(new)
weixin_30385925的博客
11-03 74
这些东西是平时遇到的, 觉得有一定的价值, 所以记录下来, 以后遇到类似的问题可以查阅, 同时分享出来也能方便需要的人, 转载请注明来自RingOfTheC[ring.of.the.c@gmail.com] 1. new 前提知识: 区分new和new操作符 new 的过程 1. 调用new操作符获取内存 2. 在内存上执行构造函数 ...
关于C++的placement new和placement delete
程序猿
03-27 9591
昨天发贴提了个问题，今天总结在这。原帖点击进入，有兴趣可以看看，我呆会儿还会说。 C++的new是语言自定义的操作符，这个操作符的行为包含两件事，而且你不能改变。 第一件事：调用operator new分配内存。所以通常说的重载new函数其实重载的是operator new，你无法重载new。 第二件事：调用你要new的对象的所属类的构造函数初始化第一步中分配的内存。这就是为什么你Obj
关于placement new 和 placement delete的重载，以及basic_string重载new()实例
hanhan的博客
02-11 464
在https://blog.csdn.net/qq_42604176/article/details/111997397中已经介绍了placement new的形式。 它的形式为new()/delete().我们将分配好内存的指针送入括号中，就完成了初步的调用了。 其实我们可以定义放任何的东西到()内部。只放一个指针的版本是的new()是标准库先写好给我们的。 我们可以重载operator new，并写出多个版本，如： Foo* pf = new(300,'c')Foo; //注意，这里没有传入指针 前提
C++ 重载operator new,delete
weixin_42333471的博客
05-15 626
new operator 与operator new不是一个概念，new operator作为一个操作符，就是我们常用的new： Test* ptest = new Test(2); operator new实质上是一个用来获取内存的函数，实质上调用了malloc void* operator new(size_t size); new operator实质上是调用了“operator new...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值