第七节三大函数：拷贝函数，拷贝赋值，析构

今天开始学习另一个经典类，String（仅从三大函数的角度）。

构造函数
拷贝构造函数
拷贝赋值函数
析构函数

大家都知道，我们在创建实例的时候，编译器会自动调用class中的构造函数对实例进行初始化，而在销毁实例或生命周期结束时会自动调用其析构函数来清理内存。那么拷贝构造函数与拷贝赋值函数是什么呢？它们的作用是？

先来看一段String类接口：

class String
{
private:
    char *m_data;
public:
    String(const char* cstr=0);//构造函数
    String(const String& str);//拷贝构造函数
    String& operator=(const String&str);//拷贝赋值函数
    ~String();//析构函数
    char* get_c_str() const{return m_data};
};

再来看下面的代码：

int main()
{
    String s1();//调用构造函数
    //String S1;//调用构造函数
    String s2("hello");//调用构造函数
    String s3(s1);//调用拷贝构造函数
    String s4=s1;//调用拷贝构造函数
    s4=s2;//拷贝赋值函数
    return 0;
}

看了上面的代码，是不是对四个函数有了基本的印象呢，下面我们来深入学习。

构造函数/析构函数

inline
String::String(const char* cstr=0)//用来创建无参实例或以字符串("aaaa"或char[5])为参数的实例
{
    if(cstr)//有参
    {
        m_data=new char[strlen(cstr)+1];//为m_data开辟空间，大小为参数长度+1(存放'\0')
        strcpy(m_data,cstr);//赋值
    }
    else//无参
    {
        m_data=new char[1];//开辟大小为1的空间，存放'\0'
        *m_data='\0';
    }
}//构造函数
inline 
String::~String()
{
    delete[] m_data;//释放内存，注意用[]
}//析构函数

int main()
{
    String* p=new String("hello");//调用构造函数
    delete p;//调用析构函数
    return 0;
}//测试函数

比较中规中矩的用法。

拷贝构造函数/拷贝赋值函数/析构函数

inline
String::String(const String& str)
{
    m_data=str.m_data;
}//浅拷贝构造函数（编译器自带的那一套）

String s1="hello world";
String s2=s1;

我们知道，在执行String s1="hello world";String s2=s1;这样的操作时，编译器会调用默认拷贝构造函数，然而这种默认的拷贝构造函数只是单纯的将s1中的数据一个bit一个bit的复制过去，是一种浅拷贝，当我们的class中有point成员时，这种浅拷贝会使s1,s2中的两个point指向同一块内存，这是很危险的。这时，我们需要为编译器提供一个新的、深拷贝的拷贝构造函数。

inline
String::String(const String& str)
{
    m_data=new char[strlen(str.m_data)+1];
    strcpy(m_data,str.m_data);
}//深拷贝构造函数（无内存问题）

以上为拷贝构造函数只能解决在新建实例时对class中point成员指向问题，在实例已经创建完成后的赋值动作，同样会存在指针指向相同内存的问题，我们需要通过重载操作符'='来解决这个问题，即拷贝赋值函数。

inline
String& String::operator =(const String& str)
{
    if(this==&str)//检测自我复制(self assignment)
        return *this;
    delete[] m_data;//原理内存（原内存长度不可更改）
    m_data=new char[strlen(str.m_data)+1];//重新开辟长度适当的空间
    strcpy(m_data,str.m_data);//赋值
    return *this;//返回this
}//拷贝赋值函数

String s1("hello world");
String s2;
s2=s1;//调用拷贝赋值函数

以上就是String中的big three。

最后再来重载一下'<<'方便输出String实例

#include
ostream& operator<<(ostream& os,const String& str)
{
    os<

 
 {
    String s1("hello ");
    cout<
 
 第八节 堆，栈与内存管理 
  
  栈（Steak） 
  
 是存在于某作用域(scope)的一块内存空间(memory space)。 
  
  堆（Heap） 
  
 也成system heap,是由操作系统提供的一块global内存空间，程序可以动态分配(dynamic allocated)从其中获得若干区块(blocks)。 
 class Complex{...};
...
{
    Complex c1(1,2);//分配栈空间
    Complex* p=new Complex(3);//动态分配堆空间
}
 
 static object与global object两种都在main之前存在，（联想构造函数）在程序结束时销毁（析构函数）。 
 new：先分配memory，再调用ctor 
 Complex* pc=new Complex(1,2);
//编译器转化为
void* mem=operator new(sizeof(Complex));//分配内存（大小决定于class数据类型）,内部会调用malloc(n)
pc=static_cast(mem);//转型
pc->Complex::Complex(1,2);//构造函数
 
 delete:先调用dt,在释放memory 
 String* ps=new String(Hello);
delete ps;
//编译器转化为
String::~String(ps);//调用析构函数，杀掉class中动态分配的内存
operator delete(ps);//释放内存，内部调用free(ps)，free(ps)用来杀掉class本身(即数据成员);
 
 小结：构造函数与析构函数的作用是初始化和清理class中动态分配的内存，真正执行创建和销毁object的操作是malloc(),与free() 
 动态分配所得的内存块,in VC 
 我们创建一个Complex类（双double成员），一般会认为被动态分配8个bit。 
 但实际上，在VC中的情况是这样的(VC中每个内存块一定是16的倍数)： 
 |Complex 
 |00000041(Cookies)
 |Debugger Header(debug,32+4bit)
 |Complex Object(data,8bit)
 |00000000(pad,16bit)
 |00000041(Cookies)
 8+(32+4)+(4*2) 
 ->52 
 ->64（debug模式下） 
 | 00000011(Cookies) 
 | Complex(data,8bit)
 | 00000011(Cookies)
 8+(4*2) 
 ->16 
 以上Debug标注为在调试模式下所分配的内存。而Cookies用来记录分配内存的大小，上例中分别为00000040与00000010,利用最后一位记录是否已经分配,分配后则为00000041与00000011。 
 以上为Complex object,String object与其结构相似在这就不多做赘述。 
 下面分析一下动态分配所得的array： 
 | Complex[3] 
 | 51h(Cookies)
 | Debugger Header(debug,32+4bit)
 | 3(4bit)
 | double(24bit)
 | 00000000(pad,8bit)
 | 51h(Cookies)
 (8 *3)+(32+4)+(4 *2)+4 
 ->72 
 ->80 
 非debug模式下为： 
 (8 *3)+(4 *2)+4 
 ->36 
 ->48 
 | String[3] 
 | 41h(Cookies)
 | Debugger(32+4bit)
 | 3
 | pointer(12bit)
 | 00000000(pad,4bit)
 | 41h(Cookies) 
 (4 *3)+(32+4)+(4 *2)+4 
 ->60 
 ->64 
 array new一定要搭配array delete 
 String* p=new String[3];
delete[] p;//唤起3次dtor
//只有加"[]"编译器才会明白要清理的对象是一个数组，才会读取3,唤起三次dtor(自写，处理class中动态分配内存)
 
 如果例子中是Complex类，则不论是不是数组使用delete p都没有问题，因为不存在类中动态分配内存，所以不需要dtor，只要调用free()清理double即可，但是为了规范，方便记忆，单个object使用delete,数组使用delete[]。 
 []的本质是命令编译器读取pointer(12bit)或double(23bit)上方的用来记录数组长度的内存来获取数组长度，并唤起dtor该长度的次数。 
 第九节 扩展补充：类模板，函数模板，及其他 
 补充：static 
  
  通常100个实例就有100组数据，而函数保存在代码区，只有一份。一份函数处理多组数据，靠this指针。调用方法：c1.real()->complex::real(&c1);将地址传入this用来识别具体是哪一组数据。 
  static修饰的实例类作用域为全局，在程序结束时销毁。 
  static会使数据与函数与类分离，在内存中单独存储，且只有一份。因为没有this指针，所以static函数只能处理static数据。 
  类中声明静态实例不会分配内存（声明）。在类外初始化时分配（定义）。 
  静态函数的调用方法：（1）通过实例调用。例:Account a;a.set();（2）通过class name来调用。例：Account::set;(与临时变量语法类似)。 
  
 补充：把ctors放在private中 
 单例模式(Singleton) 
 class A
{
public:
    static A& getInstance(return a;);//对外窗口
    setup(){...}
private:
    A();//构造函数
    A(const A& rhs);//拷贝构造函数
    static A a;//实例
};
 
 然而上述方法还不够完美，实例a在object创建时就已经存在，有些浪费空间，最好是在使用时才创建。只需要将创建实例的过程放到对外窗口中即可，只有外界通过窗口访问时再创建。 
 class A
{
public:
    static A& getInstance();
    setup(){...}
private:
    A();
    A(const A& rhs);
    ...
};
A& A::getInstance()
{
    static A a;
    return a;
}
 
 解析：实现单例要解决两个问题： 
 （1）控制权限，不允许到处创建实例。解决方法：将构造函数放在private中，则只允许在类内创建实例。 
 （2）控制数量，只允许创建一个实例。解决方法：使用static修饰实例。 
 补充：cout 
 在这里先抛出一个问题，为什么cout可以接受可种各样的数据并弹出呢？ 
 cout属于_IO_ostream_withassign类，继承于ostream，我们来看一下ostream的定义。 
 class ostream:virtual public ios
{
public:
    ostream& operator<<(char c);
    ostream& operator<<(unsigned char c){return(*this)<<(char)c;}
    ostream& operator<<(signed char c){return (*this)<<(char)c;}
    ostream& operator<<(const char *s);
    ostream& operator<<(const unsigned char *s){return (*this)<<(const char*)s;}
    ostream& operator<<(const signed char *s){return (*this)<<(const char*)s;}
    ostream& operator<<(const void *p);
    ostream& operator<<(int n);
    ostream& operator<<(unsigned int n);
    ostream& operator<<(long n);
    ostream& operator<<(unsigned long n);
    ...
}
 
 不难发现ostream中对操作符"<<"进行了大量重载，正因如此cout才可以接收各种各样的数据类型。 
 补充：类模板(class template) 
 适用情况：相同操作，不同数据 
 template
class A
{
private:
    T data;
public:
    A();
    T get(return data);
};

int main()
{
    A a;//绑定
    cout<
 
 在定义类时不指定数据类型，而是使用一个符号T来代替，之后在使用时绑定类型。 
 补充：函数模板(function template) 
 顾名思义使用在非类成员函数的模板。 
 template
T min(T& a,T& b)
{
    return a>b?b:a;//T的类型会影响具体调用那一种'>'操作符重载
}

int main()
{
    int a,b;
    cin>>a>>b;
    cout<
 
 在调用使用模板的函数时编译器会进行“引数推倒（argument deduction）”，即利用传进的实参在决定T类型，并推出返回类型或重载类型。 
 补充：命名空间(namespace) 
 以标准库为例，标准库中所有的命名都被包含在了命名空间std中，使用的方法有几种： 
  
  using namespace std;cin,cout; 
  using std::cout;std::cin,cout; 
  (NONE);std::cin,stu::cout; 
  
 更多细节深入 
 一下是不包含在课程中的内容，顺便记录一下。 
  
  operator type()const;//转换函数 
  explicit complex(...):initialization list{} 
  pointer-like object 
  function-like object 
  Namespace 
  template specialization 
  Standard Library 
  variadic template(c11) 
  move ctor(c11) 
  Rvalue reference(c11) 
  auto(c11) 
  lambda(c11) 
  range-base for loop(c11) 
  unordered containers(c11)
 ... 
  
 今天就到这吧。。。

（GeekBand）C++面向对象高级编程（上）第二周笔记（1）

第七节三大函数：拷贝函数，拷贝赋值，析构

构造函数/析构函数

拷贝构造函数/拷贝赋值函数/析构函数

第八节堆，栈与内存管理

new：先分配memory，再调用ctor

delete:先调用dt,在释放memory

动态分配所得的内存块,in VC

|Complex

| 00000011(Cookies)

| Complex[3]

| String[3]

array new一定要搭配array delete

第九节扩展补充：类模板，函数模板，及其他

补充：static

补充：把ctors放在private中

单例模式(Singleton)

补充：cout

补充：类模板(class template)

补充：函数模板(function template)

补充：命名空间(namespace)

更多细节深入

你可能感兴趣的:(（GeekBand）C++面向对象高级编程（上）第二周笔记（1）)

（GeekBand）C++面向对象高级编程（上）第二周笔记（1）

第七节 三大函数：拷贝函数，拷贝赋值，析构

构造函数/析构函数

拷贝构造函数/拷贝赋值函数/析构函数

第八节 堆，栈与内存管理

new：先分配memory，再调用ctor

delete:先调用dt,在释放memory

动态分配所得的内存块,in VC

|Complex

| 00000011(Cookies)

| Complex[3]

| String[3]

array new一定要搭配array delete

第九节 扩展补充：类模板，函数模板，及其他

补充：static

补充：把ctors放在private中

单例模式(Singleton)

补充：cout

补充：类模板(class template)

补充：函数模板(function template)

补充：命名空间(namespace)

更多细节深入

你可能感兴趣的:(（GeekBand）C++面向对象高级编程（上）第二周笔记（1）)

第七节三大函数：拷贝函数，拷贝赋值，析构

第八节堆，栈与内存管理

第九节扩展补充：类模板，函数模板，及其他