C++ Primer Plus学习笔记

学习资料：C++ Primer Plus（中文第六版）

 第一章

介绍c++起源，暂时跳过

第二章

• 1.只有main()可以默认返回return 0，其他函数不行，否则有可能会造成编译错误
• 2.c++源文件在不同的编译环境下有多种扩展名，例如C、cc、cxx、c、cpp
• 3.名称空间：相当于封装一个程序，在出现多个程序拥有相同名字的函数、变量名时，编译器不会混乱
• 4.声明变量：对应变量所占空间（数据类型），名字。不容易造成混乱。c++风格在首次使用变量的地方声明它，好处在于在程序中找变量，坏处是无法一目了然某程序用了哪些变量
• 5.cin,cout（都是类） 能够智能识别 变量的数据类型
• 6.int void return double是C++的关键字，main甚至cin cout都可以作为变量名，但不能够 变量 和 输出混用

第三章

1.关于变量名

• 字母下划线开头
• 不能以 __ 和 _大写 组成，这些要编译器来用

2.C++如何确定cout常量的类型：先以int为主，存不下用long long 

.

.

鉴于时间考虑，已经会的章节就不看了。直接跳到第八章

第八章

内联函数

• 相当于直接把函数内容复制到调用的地方，节省了程序跳转的时间，但同时带来了空间开销
• 不能递归

引用

• 引用变量只能在初始化的时候赋值
• 引用具有const属性
• 不能从函数中返回即将释放的引用变量（内存）
• ostream类
• width方法仅生效一次
• 值引用会降低程序速度，const指针和vonst引用，可以避免创立中间变量
• 传递类标准的方式是引用传递

p274  cin使用引用....(不懂)

默认参数

• 只能从右向左赋值形参表

重载函数

• 非const给const赋值是合法的

函数模板

• class和typename是等价的template<typename 自定义>

隐式示例化，显示实例化，显示具体化区别

• 模板；模板示例；不用模板，针对某种结构进行自定义操作

编译器选择重载函数：

• 完全匹配
• 提升转换(char,short → int,float→double)
• 标准转换(int → char , long → double)
• 用户定义的转换

关键字decltype

• 解决模板函数定义 不同数据类型算术 变量的难题

头文件包含的内容

• 函数原型
• const define
• 结构体，类声明
• 模板函数
• 内联函数

头文件写引号和尖括号的区别

ifndef的作用

• 使得一个头文件不会被包含两次，原理是忽略除第一次保护外的所有内容

第十章

接口

• 接口是一个共享框架，供两个系统交互使用。例如类中的函数成员

类的属性

• 封装
• 数据隐藏：将数据放在类的private中

Private

• class默认private，不写也没关系
• 类函数成员被当作是内联函数
• 每一个类方法只有一个存储地方，即使定义多个类

构造函数

• 初始化新建的类
• 没有返回值
• 隐式/显式调用构造函数
• 默认构造函数始终存在，如果没自定义可以不写，自定义了一定要写。倘若是后者，就必须定义默认构造函数，构造有2种方法。第一，自定义构造函数提供所有默认值；第二，无参数构造函数

析构函数

• 如果new的class，会用delete来释放内存。否则会有隐式的析构函数
• 声明方法：~类名
• 程序中使用两对大括号，使得析构函数在程序结束之前得到调用

this指针

• 指向调用对象，返回*this (*解除运算符)

P368有错误

• 常量作用域为类，用static声明（所有实体共用一个变量）或者枚举的方式，因为类不声明变量。

第十一章

友元函数

• friend关键字声明，必须在类里面声明友元函数，代表该类和哪个函数友元

关于重载<<

• 假设我们要出一个类对象trip，我们可以调用成员函数trip.show（）显示其内容。我们也可以重载<<。但如果定义为成员函数，则写法变成trip<<cout（trip 调用 cout里所有的方法，因为此时其是成员函数，肯定要对象调用方法，总结一下格式），定义成友元 就是cout<<trip。注意一下成员函数调用，和友元函数调用时的区别
• <<运算符要求左边是一个ostream引用对象，因此在上例写友元函数时，返回一个ostream引用对象
• 总之，对于重载运算符，注意一些使用规则，和实现的两种方法，对于友元函数要用到this指针，但友元的灵活性更大
• 切记不可因为重载或者友元函数产生二义性
• 一个函数后跟上const声明调用该函数不会对对象修改任何东西
• 当自己定义一个了一个名称空间x后，如果后面要用到该空间x的变量（因为不同空间可以定义同名函数变量），就需要加上x::再用

类的转换

• 补充常识：1英石＝14磅
• 显式：人为主动传参数或者进行其他操作
• 隐式：系统内部自动进行的操作或者自动产生的变量
• 若使用explicit声明构造函数，则会关闭隐式转换,只能主动调用显式转换
• 编译器碰到二义性的问题时，会报错。因为它无法决定哪一个可选，可选哪一个更优
• 只带有一个参数的构造函数，可以直接把对应的变量复制给类对象（隐式转换）
• 尽量使用显式转换！
• 用友元函数传入2个变量来做类的加法运算能让程序更健壮，理由是碰到double+class的情况，成员函数无法解决，只能用友元函数（当然，前提是在class有只需要double赋值的构造函数存在）。也可以让友元函数重载，只是要写好2次，麻烦

第十二章 类和动态内存分配

对类成员使用内存动态分配

• 静态类成员只会被创建一次，被共享使用
• ::作用域运算符
• 实现深复制而不是默认复制（浅复制），浅复制只能表面复制，深复制可以有更多优化的地方(不只是数据的复制，还有地址的不同)，需要自定义深复制。
• 复制构造函数和赋值运算符不同在于，前者用于初始化，会产生新的变量。后者不会产生新变量。

隐式和显式复制构造函数

• 隐式是默认的
• 自定义显式构造函数能够实现更多的功能，例如计算cnt

隐式和显式重载赋值运算符

• 重载赋值运算符后，可以进行深复制，即不会共用同一个地址，共用同一个地址很可能会发生问题（隐式重载运算符的危害）

使用静态类成员

• 静态类成员函数只能使用（返回）静态函数成员变量，使用范围比较窄

将定位new运算用于对象

• delete [] p  只能作用于p=nullptr or p=new char[N]，即new和delete必须互相兼容。若有多个构造函数，new的方式一定要和唯一的析构函数相兼容

关于返回对象

• 若参数都是const引用，返回const引用可以不产生变量（即不调用复制构造函数），提高程序效率

队列模拟

• 初始化和赋值不是一个概念
• 引用和const只能在初始化的时候赋值
• 若在class中有const，那么只能用构造函数的成员初始化列表语来赋值（在c++11前）
• 但是C++11后，可以在类内赋值

第十三章 类继承

基础知识

• 派生类，基类
• 在调用构造函数的时候，一定会产生新的变量，因为类中只是声明了怎么分配内存和变量。初始化使用 成员初始化列表 可以减少 赋值 的过程
• 创建派生类对象时，程序首先调用基类构造函数，再调用派生类构造函数。派生类对象过期时，先调用派生类析构函数，再调用基类析构函数
• 可以把继承类对象赋值给基类引用，因为基类的构造函数一定对继承类对象有用。反之，继承类引用不能被基类对象赋值，因为继承类构造函数会有其他成员变量，不能对基类赋值。
• 继承类存在隐式构造函数，可以将基类转化成继承类。也可以反向，将继承类对象赋值给基类对象，这样会调用隐式重载赋值运算符，只将继承类的基类部分赋值给基类对象
• 基类的构造函数如果默认，那派生类必须自定义构造函数。如果不默认，那问题不大，因为先调用基类构造函数，还是取决于不同的代码

is-a关系的继承

• is-a-kind-of

多态公有继承

• 方法 行为取决于调用该方法的对象
• 实现方法：虚函数，重新定义基类方法（覆盖）

向上和向下强制转换

• 向上：继承类到基类
• 向下：基类到继承类

虚成员函数

• 如果使用了virtual关键字声明了同名函数，则引用或者指针会进行理想中的选择。
• 方法在基类中声明了虚方法，在继承类中自动转化为虚方法
• 虚析构函数保证了析构顺序正确性
• 给基类函数定义虚析构函数，可以让派生类在结束时，调用自己的析构函数，再调用基类析构函数，有利于空间完全释放
• 友元函数不是虚函数，因为它不是成员函数
• 在派生类中重新定义不同的基类虚函数，将会覆盖基类虚函数。不过好像没什么关系？
• 哪些函数不能是虚函数：普通函数，构造函数，友元函数，内联函数，静态函数

静态联编与动态联编

• 编译时；
• 运行时，虚方法（基类通常会加虚方法）;

访问控制
让派生类可以使用基类的protected定义的变量

纯虚函数

• 虚函数后面加 = 0，代表纯虚函数，不能创建该类

第十四章 c++中的代码重用
基础知识

包含对象成员的类

• 是什么：相当于类里面有一些其他类的实例化对象
• 什么用：实现has-a
• 如何实现：直接用

私有继承 

• 是什么：声明了当前类继承了某些类。和包含不同的是，它不声明对象，只声明了类。
• 什么用：实现has-a
• 如何实现：直接用

包含和私有继承

• 一个是包含，一个是派生。那么注定，只有派生能用的，包含不能用。公有继承和私有继承区别于继承方式，公有保持不变，私有的派生类（基类都是私有变量）。暂时不能很好地体会私有继承的优点。
• 保护继承：让派生类的派生类，能直接使用父类的protect成员。感觉很鸡肋啊。。我始终可以用本身的公有函数去使用私有成员。

第十五章 友元、异常和其他

• 友元
• 假设B是A的友元类，定义顺序无关；若指定B中的某一个函数作为A的友元函数，因为在A中要声明友元函数的名字
• class A
• class B{}
• class A{}这样定义才可以。
• 和class自己定义友元函数相比较，其可以将定义放在后面。而以其他类的某个函数为友元函数时，必须友元类定义在前面。疑惑！！！
• 但是不能A的部分是B的友元，B的部分是A的友元

其实都只声明方法应该是最好的方法，等晚上回去上机试试

嵌套类

• 在类中嵌套类，具体作用：减少变量名冲突的可能性，因为作用域仅在类内

异常

• try 通过 throw 到达 catch
• 栈解退有利于完全释放空间

RTTI

• 被口诛笔伐？那可以pass了，一定会有取而代之的实现方式。PASS

类型转换运算符
dynamic_cast实现继承类向基类的转换
const_cast实现常量和变量的互相转换，但是不能跨数据类型。

throw和return的区别

• throw到上一个try，而return到上一次调用它的地方

智能指针

• 所有只能指针类只能进行显式转换
• unique_ptr 右值是临时变量可以赋值，长期变量不行
• share_ptr 引用计数，仅当计数==0的时候才delete指针
• auto_ptr<type> x(new typr)

总结：

在看C++ Primer Plus之前已经学过许多关于c++的东西，没有系统地学过。看得过程中跳过了大部分已经学过的东西，主要学的知识是关于类，还有运算符重载。有很多细节的知识没实践过容易遗忘，保留这篇博文，方便以后自己查阅。

今天把学过的知识串起来再看一遍，把几个例题做掉。C++学习暂时就算告一段落。

Problem 1

p423实现第七题，实现complex类尝试使用友元函数和成员函数解决。重载+=，-=
 

#include<cstdio>
#include<iostream>
typedef long long ll;
using namespace std;
class complex{
private:
    int img;
    int real;
public:
    complex(){img=0;real=0;}
    complex(int a,int b){img=a;real=b;}
    complex operator+(const complex & t) const {
        complex now;
        now.img=img+t.img;
        now.real=real+t.real;
        return now;
//        return complex(img+t.img,real+t.real);
    }


    complex operator-(const complex & t) const {
        complex now;
        now.img=img-t.img;
        now.real=real-t.real;
        return now;
    }
    complex operator*(const complex & t) const {
        complex now;
        now.img=img*t.img-real*t.real;
        now.real=img*t.real+real*t.img;
        return now;
    }
    complex operator~() const {
        complex now;
        now.img=img;
        now.real=-real;
        return now;
    }
    void show(){cout << real<<" "<<img << endl;}
    friend void operator +=(complex &a,complex &b);
    friend complex operator*(double m,const complex &t);
    friend ostream & operator<<(ostream &os,complex &x);
    friend istream & operator>>(istream &os,complex &x);
};

void operator += (complex &a,complex &b){
    a.img=a.img+b.img;
    a.real=a.real+b.real;
}

istream & operator>>(istream &is,complex &x){
    is >> x.real >> x.img;
    return is;
}
ostream & operator<<(ostream &os,complex &x){
    os << x.real <<" "<< x.img;
    return os;
}

complex operator*(double m,const complex &t){
    complex now;
    now.img=m*t.img;
    now.real=m*t.real;
    return now;
}

int main(void){
    complex t1,t2;
    cin >> t1 >> t2;
    t1+=t2;
    t1.show();
    cout <<"Over Loading cout"<<endl;
    cout << t1 << endl;


    return 0;

}

Problem 2

尝试派生类和基类。 重写情况（函数不同）下，不同引用赋值的调用情况。以及实现虚函数virtual不同引用的情况

#include<cstdio>
#include<iostream>
typedef long long ll;
using namespace std;

class A{
private:
    int x,y;
public:
    A(int a,int b){x=a;y=b;}
    virtual void show(){cout <<x <<" o "<< y << endl;}
};


class B : public A{
private:
    int xx;
    int yy;
public:
    B(A &c):A(c),xx(0),yy(0){} /// 注意，当继承类定义构造函数要考虑基类函数
    void show(){cout <<xx<<" x "<<yy<<endl;}
};

int main(void){
    A t1(1,2);
    B t2(t1);
    A * p=&t2;
    p->show();
    /// 如果没有virutal,一切按照指针的类型来进行，由于有了virtual，使得基类指针要考虑赋值对象的类型，考虑是否子类有虚函数的存在
    return 0;

}

Problem 3

explict的应用

#include<cstdio>
#include<iostream>
typedef long long ll;
using namespace std;

class A{
private:
    int x,y;
public:
    /// 没有explicit时可以进行隐式赋值
    explicit A(int a){x=a;y=0;}
    virtual void show(){cout <<x <<" o "<< y << endl;}
};



int main(void){
    A t=2;


    return 0;

}

Problem 4

class A,class B。指定B中某个成员函数成为A的友元函数

#include<cstdio>
#include<iostream>
typedef long long ll;
using namespace std;
class A;

class B{
public:
    B(){}
    void show(A &t);
};


class A{
private:
    int x,y;
public:
    friend void B::show(A & t);
    A(int a,int b){x=a;y=b;}
};

inline void B::show(A & t){
    cout << t.x <<" "<<t.y<<endl;
}

int main(void){
    A t1(2,3);
    B t2;
    t2.show(t1);

    return 0;

}