C++ 学习笔记

堆,栈,RAII

堆:分配内存之后需要手动释放,否则,将要造成内存泄漏

  • newdelete操作的是free store
  • mallocfree操作的是heap

new的底层就是malloc

动态获取内存都是在堆中进行的
auto ptr = new std::vector<int>()

智能指针

unique_ptr

独享它所指向的指针,也就是说,同时只有一个unique_ptr指向一个对象,不能多个unique_ptr指向一个对象,
如果说unique_ptr被销毁,那么它所指向的对象也会被销毁

不能进行拷贝复制

shared_ptr

共享他们呢所指向的指针,多个shared_ptr可以同时指向一个相同的对象,在计算机内部采用技术机制来实现
如果有对象关联的话,那么引用计数就会+1,如果智能指针减少,那么就会-1,当变成0,贼会将这个对象进行释放

删除器

在构造函数中第二个删除器就行了

  1. 可以进行拷贝复制

两者区别

unique_ptr 占用资源比较小,所以大多数还是用unique_ptr

字面量

常量是固定的,在程序执行期间不会改变,这些固定的值,就是字面量

左值和右值

左值:一般指一个特定内存的具有名称的值
右值:不指向稳定内存空间地址的匿名值(不据名对象)

通过取地址来判断左值还是右值:
如果能取到地址 就是左值,否则就是右值

x++和++x

x++:右值:首先生成一个x值的临时拷贝。然后才最x递增,最后返回临时复制内容
++x;左值:直接对x递增后马上返回自身,所以说++x是一个左值

注意:字符串常量存储在程序的数据段中,会在加载的时候开辟内存空间,可以使用&来获取字面两的地址

左值就比较强
如果函数返回的是一个值,return x 那么就会变成 右值

左值引用

传入函数的时候用 void swap(int &a,int &b); 加入

注意: 指针运算的时候会发生计算

文件操作

文件流都在<fstream>里面

复合

构造函数由内到外,析构函数由外道内,c++会默认进行执行这些代码,我们只要完成其中的函数
如果自己不写的话,那么就要调用默认的构造函数和析构函数

委托

指针,不同步,外边的函数有了,但是里面的函数有可能没有
什么是委托?
但是

继承

构造函数:先先构造自己的父类,然后再构造自己的
析构函数:先执行父类的析构函数,然后再析构自己

虚函数

non-virtual:不希望子类重新定义他
virtual:希望子类能够重新定义他
pure virtual:希望子类一定要重新定义他

#include <iostream>

class CDocument
{
private:
public:
    void on_file_open()
    {
        std::cout << "你好" << std::endl;
        std::cout << "check file status.." << std::endl;
        std::cout << "open file" << std::endl;
        Serialize();
        std::cout << "close file" << std::endl;
        std::cout << "update all views" << std::endl;

    }
    virtual void Serialize() = 0; // =0 就是纯虚函数 需要子类亲自实现进行实现
};
class CMyDoc : public CDocument
{
private:
public:
    virtual void Serialize()
    {
        std::cout << "CMyDoc::Serialize()" << std::endl;
    }
};
int main()
{
    CMyDoc myDoc;
    myDoc.on_file_open();
}

定义虚函数是允许用基类的指针来调用子类的函数
纯虚函数是为了实现一个接口,起到一个规范的作用,规范是:子类必须继承这个函数

转换函数

class Fraction
{
private:
    int a, b; // a 是分子, b 是分母
public:
    Fraction(int a, int b = 1) : a(a), b(b)
    {}

    // 当做成 double 类型的时候,就会被调用起来
    operator double() const
    {
        return 1.0 * a / b;
    }
};

### explicit

如果加上的话,就是当正确的调用构造函数的时候才会出现,不会隐式的出现这个函数,
所以只要是隐式转换,就会寄了,

`注意`: 这个函数只在构造函数的时候会出现,十分明确当正确的时候才会出现这个函数

```c++
class Fraction
{
private:
    int a;
public:
    Fraction(int a = 1) : a(a)
    {}

    Fraction operator+(const Fraction& other)
    {
        return a + other.a;
    }
};


迭代器

仿函数

不懂

namespace

如果使用using namespace std,那么就会发生冲突,所以说还是用namespace 包起来,然后再使用吧

成员模板

在模板里面的模板,在模板里面发生过变化

函数特化

面对

友元函数

外面的函数不能直接使用private里面的东西,需要加入friend 才能,否则第一个函数的自变量是自己this,

noexcept

void f() noexcept
{

}

保证这个函数不会抛出异常,

Variadic Template (不定参数的模板)

void print()
{

}
template<typename T, typename... Types>
void print(const T& first_arg, const Types& ... args)
{
    std::cout << first_arg << std::endl;
    print(args...);
}

参数可以直接输出递归输出,最后一个是 变成(分解) 1 和 0 ,就会调用第一个print()这个
(这样是处理边界条件)
注意: 应该使用

但是他可以跟这样并存,如

template<typename... Types>
void print(const Types&... args)
{
}

nullptr和 std::nullptr_t

在 c++ 中 还是建议使用 nullptr 使用,否则会有奇异

强制类型转换

  1. static_cast(expression): 编译时

    1. 将一个指向基类的指针转换为指向子类的指针,但是这样的转换不总是安全的
    2. 基本类型之间的转换(int,float,double)之间的转换
  2. const_cast(expression)

    1. 用于去除变量的只读属性
    2. 强制转换的目标类型只能是指针或者引用
  3. reinterpret_cast(expression) 将一个指针重新解释成另一个指针类型

    1. 用于指针类型之间的转换
    2. 用于整数和指针类型之间的强制转换
  4. dynamic_cast(expression):运行时

    1. 有继承关系的类指针之间的转换
    2. 有交叉关系的类指针之间的转换
    3. 具有类型检查的功能
    4. 需要虚函数的支持

防卫式声明

防止重复命名,如果多次引用,那么就会寄了
基本格式是: (注意要规范: 要大写)

#ifndef XXXXX
#define XXXXX

内容

#endif

C++线程

注意一点:
执行类的成员函数的时候,如果不是静态函数的话,那么就要保证创建一个对象,然后才能调用
必须保证对象的生命周期比自线程要长

子线程一定要回收,使用xxx.join()来回收线程

多线程会产生冲突,我们要避免冲突

std::cout是全局对象,当前对象如果全部都在搞这个,那么就寄了

我们要保证访问这个信息数据的时候,要保证线程安全,

所以说我们要用互斥锁来保证

条件变量-生产/消费者模型

当前函数的额度所有

移动构造

RAII 与 智能指针

热门相关:骑士归来   第一神算:纨绔大小姐   寂静王冠   别那么骄傲   豪门闪婚:帝少的神秘冷妻