Sunday, October 23, 2011

placement new

1. What is placement new? placement new is a overriding version of operator new which I mentioned in my last tips. The placementnew can make it possible to "new" a object on the existing memory. For example, you have a block of memory in your code, which you want to "new" a object on it. You can use placement new.

char* pool=new char[sizeof(Bob)]; //initialize a block of memory
Bob* bob2=new(pool)Bob(2); //"new" a Bob in the pool
You can either "new" Bob on stack or on heap. The example is on the heap.
In fact, the placement new is the step 2 of new operator which I mentioned in my last tips. It just invokes the constructor. Since you cannot invoke the constructor explicitly, you can use placement operator instead. 

2. The problem now is how to release these memory.
I found some materials on the internet which confused me a lot. So I did a sample program myself.

using namespace std;

class Bob{
 int index;
 char buffer[7];
 Bob(int i){
  buffer[1]=' ';
  buffer[4]=' ';
  cout<<"Bob"<<index<<" is born in constructor"<<endl;
 void Say(){
  cout<<"Bob"<<index<<" died in destructor"<<endl;

void test(){
 char* pool=new char[sizeof(Bob)]; //on heap
 Bob bob1(1); //on stack
 Bob* bob2=new(pool)Bob(2);
 Bob* bob3=new(&bob1)Bob(3);
 delete bob2;
 //instead of delete bob2 you can also do the following
 delete[] pool;
 //we usaully do the later because placement is usaully used to
 //manage the memory, which means we can declare a block of
 //memory from heap in advance, than manage it, when the program
 //is done, we delete the memory.

 //the stuff in the stack will be released automatically
 //(including destructor)


void main(){
 char a;

(1).if the memory is on the heap, we usually invoke the destructor explicitly and then delete the block of memory. This is probably the only situation that need to invoke destructor explicitly.
(2).if the memory is on the stack, let it go. It will invoke your destructor automatically. 

This is a good way to manage your memory. Just declare a block of memory, do what you want on it, then delete it.

operator new and new operator and overloading

1. new and delete are very complex, it is worth to do some research on it.
first thing I want to mention is about operator new and new operator. 
new operator is a keyword in the C++ just like sizeof, you can do nothing on it(you cannot try to change them). In fact, when you write the expression
Bob* bob=new Bob();
 C++ do 3 steps for you.
First, they allocate a block of memory for you(actually, you will find that this step is invoke the function new operator) , then invoke the constructor, finally, they return you a pointer. 

We cannot change the whole operator new, but we can do something for each step.

for first step, you can overload the new operator, this is an operator just like + operator,you can overload this operator.
So you can do this in your code:
void *operator new(size_t size); 
 //this is most basic overloading for new operator, placement new 
//and something else will come soon in next tips
for the second step you can override you constructor.

third step is nothing but return a pointer. 

2.Delete operator also does the similar things. But the destructor is invoked before the delete operator. One thing you should never forget, if you overload the new operator, please never forget your delete operator! because who knows what you did in your new operator.

let's look some codes here to know what happened.

using namespace std;
class Bob{
 int a;
 int c;
 Bob(int a_,int c_){
  cout<<"Bob constructor"<<endl;

 void *operator new(size_t size){
  void* p=malloc(size);
  cout<<"Bob new"<<endl;
  return p;
 void operator delete(void* ptr){
  cout<<"Bob died in delete"<<endl;
  cout<<"Bob is killed in destructor"<<endl;

void main(int argc,char* arg[]){
 Bob* bob=new Bob(1,2);
 delete bob;
 char a;

Bob new
Bob constructor
Bob is killed in destructor
Bob died in delete

Saturday, September 24, 2011

转 C++结构体实例和类实例的初始化



struct S {  //class S 效果一样
    int            x;
    unsigned short y;
S testS1={100,123};
S testS2={200};//未指定的数据成初始化认值,os2.y=0;
S TestS[4]={ {100,10},
             {300} };//未指定的初始化认值,os[2].y,os[3].x,os[3].y


struct S { //class S可自行试验果相同
        int x;
        double y;
        S(int idemo,double ddemo) {x=idemo;y=ddemo;}
        void show(void) {cout<<x<<''/t''<<y<<endl;}
S os1;//构造函数(无参构造函数)
S os2(1000,2.345);
S os3=S(2000,4.567);
S os[4]={S(10,1.234),S(20,2.234)};//未初始化的将用默构造函数。如此没有默构造函数会出

        S os3=S(2000,4.567);句中,因是声明并初始化os3象,所以将S(int,double)构造函数os3行初始化。
        S os3(2000,4.567); 等价于 S os3=S(2000,4.567);
        但如果os3存在了,S os3(100,1.234);os3=S(2000,4.567)表示用一个临时对赋值给os3,将operator=,然后系临时产生的象。系=运算是将源象的数据成值复制到目标对象中的数据成中。


#include <iostream>
using namespace std;
class C {
        int x;
        C(int idemo) {x=idemo;}
        void show(void) {cout<<x<<endl;}
struct S {
        int x;
        S(int idemo) {x=idemo;}
        void show(void) {cout<<x<<endl;}
int main(int argc, char *argv[]){
    C oc=1000;//不能企加花括号;
    S os=2000;//不能企加花括号;
    return EXIT_SUCCESS;