Linux 学习记录45(C++篇)

Linux 学习记录45(C++篇)

@

一、纯虚函数和抽象类

1. 纯虚函数

直接让虚函数=0就是纯虚函数

虚函数：virtual void show(){}；
纯虚函数：virtual void show()=0；

纯虚函数在子类中必须重写，如果不重写，子类也不能实例化对象

2. 抽象类

含有纯虚函数的类就叫抽象类
抽象类不能被实例化

/*抽象类*/
class test
{
private:
    string str;
    int num;
public:
    /*纯虚函数*/
    virtual void show()=0;

protected:

};

class cls1:public test
{
public:
	/*必须重写纯虚函数*/
    void show();
};

int main()
{
    cls1 buf;
    buf.show();
    return 0;
}

二、C++中的异常处理

异常指：程序在运行阶段出现的问题，即没有语法错误但是存在逻辑问题
在遇到问题时可以手动抛出异常的现象（throw）

抛出异常 → 处理/捕获异常

注意事项：
1. 抛出异常的位置要放在发生异常之前
2. try...catch中存放的是所有可能发生异常的代码
3. catch可以直接通过抛出异常的类型来判断是哪一种异常情况
4. 如果同一类型有多种情况，可以在catch里，对具体获取到的异常的数值再进行判断

1. 抛出异常

void fun(int a,int b)
{
    if(b==0)
    {   /*如果除数为0即为发生异常，同时抛出异常,并且异常为cahr类型*/
        throw 'e';
    }else
    {
        cout << "a/b=" << (a/b) << endl;
    }
}

int main()
{
    fun(6,2);
    cout << "---------------" << endl;
    fun(6,0);
    cout << "---------------" << endl;
    return 0;
}

输出>>

2. 处理/捕获异常

try...catch

void fun(int a,int b)
{
    if(b==0)
    {
//        throw 'e';
        throw char ('e');
        /*如果除数为0即为发生异常，同时抛出异常error*/
//        throw string ("error");
    }else
    {
        cout << "a/b=" << (a/b) << endl;
    }
}

int main()
{
    try
    {
        fun(6,0);
    } catch (int)//判断抛出异常的类型
    {
        cout << "int 类型的错误" <<endl;
    } catch (char b)//判断抛出异常的类型
    {
        cout << "char 类型的错误" <<endl;
        cout << b <<endl;
    } catch (string a)//判断抛出异常的类型
    {
        /*此时a接收到的字符串就是异常抛出的字符串*/
        cout << "string 类型的错误" <<endl;
        cout << a <<endl;
    }
    return 0;
}

三、模板(template)

模板也可以实现多态，也是泛式编程的一种,实现得上静态多态

1. 模板函数

一个模板仅对一个函数生效

1. 对于同一个函数，往往可以传多个不同的数据类型，需要实现多个，使用模板函数可以解决这个问题
2. 模板函数根据调用时传的参数，来具体实现函数的功能
3. 模板函数的调用方式:1、隐式调用(不给出模板中数据类型的调用方式)。2、显式调用(调用时给出模板中的数据类型

(1. 模板函数的定义和调用

模板定义：template<typename T1,typename T2>  定义了一个模板，模板可以接收两个不同的数据类型[T1/T2]

例：

/*定义模板*/
template<typename T1,typename T2>

T1 add(T1 a,T1 b)
{
    return a+b;
}
int main()
{
    int num1=10;
    int  num2=15;
    /*显式调用*/
    cout << add<int,int>(num1,num2) << endl;
    /*显式调用*/
    cout << add<int,double>(num1,num2) << endl;
    return 0;
}
=================================================
/*定义模板*/
template<typename T1>
T1 add(T1 a,T1 b)
{
    return a+b;
}
int main()
{
    int num1=10;
    int  num2=15;    
    cout << add(num1,num2) << endl;
    return 0;
}
==============模板类型特化================
/*class表示该类型使用默认数据类型*/
template<class T1,typename T2>
T2 add(int a,T2 b)
{
    return a+b;
}
==============模板类型特化================
template<typename T1 = int,typename T2>
T2 add(int a,T2 b)
{
    return a+b;
}

(2. 模板函数需要显性调用的时机

1. 当模板提供了两种数据类型，但是模板函数只有一种数据类型时，需要在函数调用处显性调用模板函数:函数名<数据类型1、数据类型2···>(形参) -----><>对应的是模板，()对应参数
2. 对于实参是字符串常量，想要不强转实现函数调用，需要显性调用模板函数

2. 模板类

1. 对于同一功能的类，由于数据类型的不同，可能会出现重复定义的现象(链表中的节点)
2. 如果定义模板类，只能显性调用
3. 如果模板类中的函数，想要实现类内声明，类外定义，需要在定义函数的位置重新写一遍模板

/*定义模板*/
/*class表示该类型使用默认数据类型*/
template<typename T1>
class test
{
    T1 buf;
public:
    test()
    {}
    test(T1 a):buf(a)
    {}
    /*类内声明*/
    void show(void);

};

/*类外定义*/
template<typename T1>//再次写出模板
void test<T1>::show(void)//显性调用
{
    cout << buf << endl;
}

3. 模板函数和模板类实现的机制

二次编译/延时编译

在编译过程中，第一次遇到模板时，之进行语法分析，并不实现，在继续编译到模板调用时，会根据得到的类型，再次对模板部分的代码编译，并实现模板类和模板函数。

四、C++中的类型转换

在C++中仍然支持C语言的强制类型转换

格式：关键字<新类型>原有变量

关键字	功能
const_cast	将常量指针的常属性取消
static_cast	类型转换，基本上所有的类型都可以使用，类似于C中的类型转换
dynamic_cast	将父类指针，转换成子类指针（依托于多态实现）如果转换失败返回空地址
reinterpret_cast	重新解释数据类型(不建议使用，不会检测任何类型匹配问题)

五、lambda表达式

lambda表达式多用于实现轻量级函数

lambda表达式是C++11开始支持的特性

1. 定义

定义：[]()mutable->返回值{函数体};

[捕获列表](参数列表)mutable->返回值{函数体};
1. [捕获列表]:从外部获取数据
2. (参数列表):和普通函数一致
3. {函数体}：和普通函数一致
4. 返回值
*****************************************
int main()
{
    int num1=10;
    int num2=12;

//    auto fun=[++num1,num2++]()->int{return num1+num2;};//这里捕获列表内的值默认是常量
    auto fun1=[=]()->int{return num1+num2;};//按值捕获外部所有变量
    auto fun2=[&]()->int{return num1+num2;};//按引用捕获外部所有变量
    auto fun3=[=,&num1]()->int{return num1+num2;};//引用捕获指定变量，其他变量按值捕获
    auto fun4=[&,num1]()->int{return num1+num2;};//值捕获指定变量，其他变量引用捕获
    auto fun5=[num1,num2]()->int{return num1+num2;};//值捕获指定变量

    cout << fun1() << endl;
    cout << fun2() << endl;
    cout << fun3() << endl;
    cout << fun4() << endl;
    cout << fun5() << endl;

    return 0;
}

六、标准模板库

1. C++中的标准模板库STL

(Standard Template Library标准模板库) 是通用类模板和算法的集合，它提供给程序员一些标准的数据结构的实现如 queues(队列), lists(链表), 和 stacks(栈)等.

1. 标准模板库Vectors

类似于数据结构中的顺序表 #include <vector>

Vectors 包含着一系列连续存储的元素,其行为和数组类似。访问Vector中的任意元素或从末尾添加元素都可以在常量级时间复杂度内完成，而查找特定值的元素所处的位置或是在Vector中插入元素则是线性时间复杂度。

(1. 常用函数

1、vector();  
vector( size_type num, const TYPE &val );  
vector( const vector &from );  
vector( input_iterator start, input_iterator end );
2、求实际的大小:size_type size();
3、求最大容量:size_type capacity();
4、弹出队尾元素:void pop_back();
5、插入元素:void push_back(const TYPE &val );
6、访问:TYPE at( size_type loc );   at会检查越界问题，并且at返回的是指定位置元素的引用
7、使用insert进行插入:iterator insert( iterator loc, const TYPE &val );
8、返回第一个元素的迭代器:iterator begin();
9、清空所有元素:void clear();
10、对Vector的判空:bool empty();
11、返回起始位置的引用:TYPE front();
12、返回末尾位置的引用:TYPE back();
13、返回末尾位置下一个位置的迭代器:  iterator end();
14、对Vector中的元素赋值，使用数据范围赋值: void assign( input_iterator start, input_iterator end );

思维导图