C++学习day10之构造器

#include<iostream>
#include<cstring>
using namespace  std;


/*
 *看我们前面所实现的，都会有一个init初始化，
 *然后我们想，这个初始化的工作能不能自动完成，比如你用string的时候
 *你也没使用str.init(),我们不需要，实际上就是我们要学习的第一个叫做构造器
 *构造器是什么东西，就是在构造对象的时候自动初始化
 *
 * 构造器，英文叫做constructor，叫构造器
 * 1.与类名相同，无返回，被系统生成对象时自动调用，所以这里我们首先要想到的
 *   就是用于初始化。
 * 2.可以有参数，构造器的重载，默认参数
 * 3.如果我们什么构造器都不添加的话，系统会有一个默认的无参空的构造器。若提
 * 供，则不再生成默认构造器。
 *如下
 *
    class Stack
    {
    public:
        Stack()
        {
            top=0;
            space=new char[1024];
            memset(space,0,1024);
        }
        Stack(int i)
        {
            //但是这里注意，这里的i是个局部变量，要想这个类里面的函数
            //访问的话，需要这要处理。
            top=0;
            _size=i;
            space=new char[i];
            memset(space,0,i);
        }
    private:
        char *space;
        int top;
        int _size;
    }
    int main()
    {
        //这里会重载上面有参数的。
        Stack stack(100);
        //下面这个是重载那个没有参数的。
        //这里有个疑惑，为什么不是Stack stack();
        //你想想 Stack stack();和void func();是不是一样的。所以为了避免冲突
        Stack stack;

        return 0;
    }
*/
#if 0
/*
 *无参的就无参了，有参的怎么办，我想玩默认
 */
 class Stack
 {
  public:
      Stack();
      Stack(int i=100)
      {
        top=2;
      }

    int getTop()
    {
        return top;
    }
  private:
    int top;
    char *space;
 };
Stack::Stack()
{
    top=1;
}


int main()
{
//这个就有问题了，因为它不知道是选Stack()还是Stack(int i=100);
//    Stack stack;
    int i=stack.getTop();
    cout<<i<<endl;
    return 0;
}
#endif
#if 0
struct Node
{
    int data;
    struct Node *next;
};

class List
{
public:
    List()
    {
        void createList();
    };
    void traverseList();
    void createList();
    void insertList(int d);
private:
    Node * head;
};

void List::createList()
{
    head=new Node;
    head->next=NULL;
};

void List::insertList(int d)
{
    
        Node *tail=new Node;
        tail->data=d;
        tail->next=head->next;
        head->next=tail;
        cout<<"insert"<<tail->data<<endl;
};
void List::traverseList()
{
    Node * ph=head->next;
    while(ph != NULL)
    {
        cout<<ph->data<<endl;
         ph=ph->next;  
    }
    
}
int main()
{
    List list;
    int i;
    for(i=0;i<=9;i++)
    {
        list.insertList(i);
    }
    list.traverseList();
    return 0;


}
#endif

/*
 *析构器：叫做destructor 
 *1,有个~号，除了这个~与类名相同，无参数，无返回值。
 *2.对象消失的时候，自动被调用
 *3.若是提供，系统自己生成一个空析构器
 *用于对象销毁的时候的内存处理工作。
 */ 
//使用例子
class Stack
{
public:
    Stack()
    {
        top=1;
    
    }
    Stack(int i)
    {
        top=2;
    }
    ~Stack()
    {
        cout<<"hello"<<endl;
    }
private:
    int top;
};
/*
 * 第一种用法
int main()
{
{
    Stack stack;
}
    return 0;
}
*/
/*
 * 第二种用法
int main()
{
    Stack * stack=new Stack;
    delete stack;
}
*/