美文网首页程序员
（GeekBand）C++面向对象高级编程（上）第二周笔记（1）

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

作者: Linary_L | 来源:发表于2016-10-16 23:13 被阅读0次

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

    今天开始学习另一个经典类，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<iostream>
ostream& operator<<(ostream& os,const String& str)
{
    os<<str.get_c_str();
    return os;
}

    {
    String s1("hello ");
    cout<<s1;
}

    第八节 堆，栈与内存管理

    • 栈（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<Complex*>(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

    1. 通常100个实例就有100组数据，而函数保存在代码区，只有一份。一份函数处理多组数据，靠this指针。调用方法：c1.real()->complex::real(&c1);将地址传入this用来识别具体是哪一组数据。
    2. static修饰的实例类作用域为全局，在程序结束时销毁。
    3. static会使数据与函数与类分离，在内存中单独存储，且只有一份。因为没有this指针，所以static函数只能处理static数据。
    4. 类中声明静态实例不会分配内存（声明）。在类外初始化时分配（定义）。
    5. 静态函数的调用方法：（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<typename T>
class A
{
private:
    T data;
public:
    A();
    T get(return data);
};

int main()
{
    A<int> a;//绑定
    cout<<a.get()<<endl;
    return 0;
}

    在定义类时不指定数据类型，而是使用一个符号T来代替，之后在使用时绑定类型。

    补充：函数模板(function template)

    顾名思义使用在非类成员函数的模板。

    template<class T>
T min(T& a,T& b)
{
    return a>b?b:a;//T的类型会影响具体调用那一种'>'操作符重载
}

int main()
{
    int a,b;
    cin>>a>>b;
    cout<<min(a,b);
    return 0;
}

    在调用使用模板的函数时编译器会进行“引数推倒（argument deduction）”，即利用传进的实参在决定T类型，并推出返回类型或重载类型。

    补充：命名空间(namespace)

    以标准库为例，标准库中所有的命名都被包含在了命名空间std中，使用的方法有几种：

    1. using namespace std;cin,cout;
    2. using std::cout;std::cin,cout;
    3. (NONE);std::cin,stu::cout;

    更多细节深入

    一下是不包含在课程中的内容，顺便记录一下。

    1. operator type()const;//转换函数
    2. explicit complex(...):initialization list{}
    3. pointer-like object
    4. function-like object
    5. Namespace
    6. template specialization
    7. Standard Library
    8. variadic template(c11)
    9. move ctor(c11)
    10. Rvalue reference(c11)
    11. auto(c11)
    12. lambda(c11)
    13. range-base for loop(c11)
    14. unordered containers(c11)
      ...

    今天就到这吧。。。

    相关文章

      网友评论

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

        本文链接：https://www.haomeiwen.com/subject/qajayttx.html

        延伸阅读

        深度阅读

        • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

        栏目导航

        热点阅读

        程序员

        关于我们|服务条款|联系我们|（GeekBand）C++面向对象高级编程（上）第二周笔记（1）|投稿指南|网站地图|RSS订阅|排版工具|手机版

        提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

        Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

        备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

        本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

        所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！