利用条件表达式完成下面的命题:学习成绩成绩>=90分的同学用A表示，学习成绩在60～89分的同学用B表示哦=，学习成绩在60分以下的同学用C表示.

int gra=0;

class

class 是一种用于创建用户定义的数据类型的关键字。它是面向对象编程（OOP）的基本概念之一。通过使用 class，您可以将数据成员（属性）和成员函数（方法）封装在一个单一的实体中，从而使代码更有组织性和可维护性。

语法： class 类名 {访问权限 : 属性\行为}；

class 的功能与struct类似，但提供了更为丰富的功能.

class 可以在设计的时，可以把属性和行为放在不同的权限下，加以控制.

权限的分类：

• public 公共权限
• protected 保护权限
• private 私有权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

//公共权限  public
//保护权限  protected
//私有权限  private
//私有权限与保护权限在类内可以访问，在类外不可以访问
class Num
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
public:
    void func()
    {
m_A=10;
        m_B=20;
        m_C=30;
    }
}

int main()
{
Num m;
    m.m_A=10;
    //m.m_B=20;//类外不可以访问
    //m.m_C=30;
}

class与struct的区别：

• struct 默认权限为公共
• class 默认权限为私有

对象的初始化清理

对象的初始化和清理是两个非常重要的安全问题.

一个对象或者变量没有初始状态，对其使用后果未知

同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会给我们提供空实现

构造函数

构造函数语法： 类名(){}

1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

1
2
3
4
5
6
7
8
9

class Num
{
public:
    Num(int a): m_A(a)
    {
cout << "gz" << endl;
    }
    int m_A;
};

构造函数的分类：

• 按参数
  • 有参构造
  • 无参构造
• 按类型
  • 普通构造
  • 拷贝构造

构造函数的调用方法：

• 括号法

  1 2 3

  Person P;//默认构造时后面不要加括号 Person p1(10); Person p2(p1);

• 显示法

  1 2 3

  Person p; Person p1=Person(10); Person P2=Person(p2);

• 隐式转换法

  1 2	Person p4=10; Person p5=p4;//相当于Person p5=Person(10);

explcit

在 C++ 中， explicit 关键字用于防止编译器进行隐式类型转换。当您将构造函数或转换函数声明为 explicit 时，这意味着该构造函数或转换函数只能由程序员显式调用，而不能由编译器隐式调用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class P
{
public:
    P()
    {

    }
    P(int a)
    {
        m_A = a;
    }
    explicit P(P& a)
    {
        m_A = a.m_A;
    }
    int m_A;
};

int main()
{
    P p;
    p.m_A = 1;
    //P p1 = p;//会报错，因为声明不可以隐式类型转换
    P p1=P(1);
    cout << p1.m_A << endl;
    return 0;
}

拷贝构造函数调用时机

c++拷贝构造函数调用时机

• 使用一个创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值(做参数)
• 以值的方式返回局部对象(做返回值)

构造函数调用规则：

默认情况下，c++编译器至少给一个类添加3个函数

1.默认构造参数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性值进行拷贝

规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，c++不会在提供其他的构造函数

深浅拷贝

浅拷贝：简单的赋值操作

深拷贝：在堆区重新申请空间，进行拷贝操作.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

class Num
{
public:
    Num()
    {
        cout << "gz" << endl;
    }
    Num(const Num &other)
    {
        m_A=other.m_A;
        m_B=new int (*other.m_B);
        cout << "kb" << endl;
    }
    ~Num()
    {
        if(this->m_B)
        {
            delete this->m_B;
            this->m_B=nullptr;
        }
    }
    int m_A;
    int *m_B;
};

int main()
{
    Num a;
    a.m_A=1;
    a.m_B=new int(20);
    Num b(a);
    cout << b.m_A << endl;
    cout << *b.m_B << endl;
    cout << a.m_B << endl;
    return 0;
}

class 与 struct

C++中的 struct 和 class 基本是通用的，唯有几个细节不同：

• 使用 class 时，类中的成员默认都是 private 属性的；而使用 struct 时，结构体中的成员默认都是 public 属性的。
• class 继承默认是 private 继承，而 struct 继承默认是 public 继承。
• class 可以使用模板，而 struct 不能。

引用

作用：给变量起别名

语法：数据类型 &别名 =原名

注意事项

• 引用必须要初始化
• 引用一旦初始化后，就不可以更改

引用可以简化指针的用法.

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

通过引用参数产生的效果按地址传递是一样的。引用的语法更加的简单。

引用是可以作为函数的返回值存在的.

不返回局部变量的引用.

函数的调用可以作为左值.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int sum1 = 0;
int& sum(int &a,int &b) 
{
    sum1 = a + b;
    return sum1;
}

int main()
{
    int a=10;
    int b=10;
    sum(a,b)=30;
    cout << sum1 << endl;    
    return 0;
}

本质：引用的本质在c++内部实现是一个指针常量.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void func(int &ref)
{
    ref=100;
}

int main()
{
int a=10;
    //自动转换为int *const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可以改
    int &ref=a;
    ref=20;
    
    func(a);
    return 0;
}

左值 & 右值

C++中所有的值都必然属于左值、右值二者之一.

左值是指表达式结束之后依然存在的持久化对象

右值是之表达式结束时就不再存在的临时对象.

所有的具有变量或者对象都是左值，而右值不具有名称.很难得到左值和右值的真正定义，但是有一个可以区分的便捷方法：看能否对表达式取地址，如果可以，则为左值，否则为右值。

右值又分为 将亡值和纯右值。

纯右值是C++98标准中右值的概念，如非引用返回的函数返回的临时变量值;

而将亡值则是c++新增的和右值引用相关的表达式，这样的表达式通常是将要移动的对象。&&函数返回值、std::move()函数的返回值等.

categories来说，c++11前，只有左值(lvalue)和右值(rvalue)；c++11后，任何value categories(值类型)都是下面的三种之一：lvalue， xvalue， prvalue。gvalue为广义左值，包括lvalue和xvalue，rvalue为右值，包括xvalue和prvalue，可见xvalue可以是左值也可以是右值。

纯右值(prvalue)：纯右值是传统右值的一部分，纯右值是表达式产生的中间值，不能取地址。 纯右值一定会在表达式结束后被销毁。

一般有以下的条件：

1. 本身就是纯粹的字面值，如3、false.
2. 求值结果相当于字面值或是一个不具名的临时变量.

消亡值(xvalue)是c++11的不具名的右值引用引入的。 以下情况的表达式求值结果为xvalue，准确的说叫不具名右值引用，这种属于新的”右值”，由右值引用带来，通常用来完成移动构造或移动赋值的特殊任务。事实上，将亡值不过是C++11提出的一块晦涩的语法糖。它与纯右值在功能上及其相似，如都不能做操作符的左操作数，都可以使用移动构造函数和移动赋值运算符。当一个纯右值来完成移动构造或移动赋值任务时，其实它也具有“将亡”的特点。一般，我们不必刻意区分一个右值到底是纯右值还是将亡值。

左值引用 & 右值引用

c++98中的引用很常见了，就是给变量取了个别名，在c++11中，因为增加了右值引用(rvalue reference)的概念，所以c++98中的引用都称为了左值引用(lvalue reference**)**。 c++11中的右值引用使用的符号是&&

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class A{
public:
int a;    
};

A getTemp()
{
    return A();
}

int main()
{
    int a=10;
    int &refA = a;//左值引用
    //int &ref2 = 2; //编译错误
    int &&ref1=1;//右值引用
    int b =5;
    //int && refB =b;//编译错误，不能将一个左值赋值给一个右值引用
    A&& refIns = getTemp();//函数返回值是 右值
    return 0;
}

getTemp()返回的右值本来在表达式语句结束后，其生命也就该终结了（因为是临时变量），而通过右值引用，该右值又重获新生，其生命期将与右值引用类型变量refIns的生命期一样，只要refIns还活着，该右值临时变量将会一直存活下去。实际上就是给那个临时变量取了个名字。

注意：这里refIns的类型是右值引用类型(int &&)，但是如果从左值和右值的角度区分它，它实际上是个左值。因为可以对它取地址，而且它还有名字，是一个已经命名的右值。

常量左值引用

左值引用只能绑定左值，右值引用只能绑定右值，如果绑定的不对，编译就会失败。但是，常量左值引用却是个奇葩，它可以算是一个“万能”的引用类型，它可以绑定非常量左值、常量左值、右值，而且在绑定右值的时候，常量左值引用还可以像右值引用一样将右值的生命期延长，缺点是，只能读不能改。

1

const A &a =getTmp();//不会报错

1
2
3
4
5
6
7
8
9
10
11
12

int max(const int &a,const int &b)
{
    return a+b;
}

int main()
{
    int a=1;
    int b=2;
    cout << max(1,2) << endl;
    return 0;
}

总结

T是一个数据类型

1. 左值引用，使用T&只能绑定左值
2. 右值引用，使用T&&只能绑定右值
3. 常量左值，使用const T&，既可以绑定左值也可以绑定右值
4. 已命名的右值引用，编译器会认为是个左值
5. 编译器有返回值优化，但不要过于依赖(-fno-elide-constructors)

移动语义

移动构造函数 & 移动赋值函数

用c++实现一个字符串类MiniString，MiniString内部管理一个C语言的char *数组，这个时候一般都需要实现拷贝构造函数和拷贝赋值函数，因为默认的拷贝是浅拷贝，而指针这种资源不能共享。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

class MiniString
{
public:
    static size_t kbsize;
    MiniString(const char *str)
    {
        if(str)
        {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        }
        else
        {
            m_data = new char[1];
            *m_data = '\0';
        }
    }
    MiniString(const MiniString &other)
    {
        kbsize ++;
        m_data=new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        //cout << "kb" << kbsize << endl;
    }   
    MiniString &operator=(const MiniString &other)
    {
        if(this==&other)
        {
            return *this;
        }
        delete[] m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    ~MiniString()
    {
        if(m_data)
        {
            delete[] m_data;
        }
    }
private:
    char *m_data;
};

size_t MiniString::kbsize =0;

int main()
{
    vector<MiniString> v;
    v.reserve(1000);
    for(int i=0; i<1000; i++)
    {
        v.push_back(MiniString("hello world!"));
    }
    cout << MiniString::kbsize << endl;

    return 0;
}

代码执行了1000次拷贝构造函数，如果MiniString("hello")构造出来的字符串本来就很长，构造一遍就很耗时了，最后却还要拷贝一遍，而MiniString("hello")只是临时对象，拷贝完就没什么用了，这就造成了没有意义的资源申请和释放操作，如果能够直接使用临时对象已经申请的资源，既能节省资源，又能节省资源申请和释放的时间。而C++11新增加的移动语义就能够做到这一点。

移动语义避免了移动原始数据，而只是修改了记录。要实现移动语义就必须增加两个函数：移动构造函数和移动赋值构造函数。必须让编译器知道什么时候需要复制，什么时候不需要复制。这就是右值引用发挥最大作用的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

#include <iostream>
using namespace std;
#include <cstring>
#include <vector>

class MiniString
{
public:
    static size_t kbsize;
    static size_t movesize;
    static size_t Fkbsize;
    static size_t Fmovesize;
    MiniString(const char *str)
    {
        if(str)
        {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        }
        else
        {
            m_data = new char[1];
            *m_data = '\0';
        }
    }
    MiniString(const MiniString &other)
    {
        kbsize ++;
        m_data=new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        // cout << "kb" << kbsize << endl;
    } 
    MiniString(MiniString &&other)
    {
        m_data=other.m_data;
        movesize ++;
        other.m_data=NULL;
    }
    MiniString &operator=(const MiniString &other)
    {
        Fkbsize ++;
        if(this==&other)
        {
            return *this;
        }
        delete[] m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    MiniString &operator=(MiniString && other)
    {
        Fmovesize++;
        if(this==&other)
        {
            return *this;
        }
        delete[] m_data;
        m_data=other.m_data;
        other.m_data=NULL;
        return *this;
    }
    ~MiniString()
    {
        delete[] m_data;
    }
private:
    char *m_data;
};

size_t MiniString::kbsize =0;
size_t MiniString::movesize=0;
size_t MiniString::Fkbsize=0;
size_t MiniString::Fmovesize;

int main()
{
    vector<MiniString> v;
    v.reserve(1000);
    for(int i=0; i<1000; i++)
    {
        v.push_back(MiniString("hello world!"));
    }
    cout <<"kbsize\t"<< MiniString::kbsize << endl;
    cout <<"Fkbsize\t"<< MiniString::Fkbsize << endl;
    cout <<"movesize\t"<< MiniString::movesize << endl;
    cout <<"Fmovesize\t"<< MiniString::Fmovesize << endl;

    return 0;
}

移动构造函数与拷贝构造函数的区别是，拷贝构造的参数是const MiniString& str，是常量左值引用，而移动构造的参数是MiniString&& str，是右值引用，而MiniString("hello")是个临时对象，是个右值，优先进入移动构造函数而不是拷贝构造函数。而移动构造函数与拷贝构造不同，它并不是重新分配一块新的空间，将要拷贝的对象复制过来，而是”偷”了过来，将自己的指针指向别人的资源，然后将别人的指针修改为nullptr，这一步很重要，如果不将别人的指针修改为空，那么临时对象析构的时候就会释放掉这个资源，”偷”也白偷了。

不用奇怪为什么可以抢别人的资源，临时对象的资源不好好利用也是浪费，因为生命周期本来就是很短，在你执行完这个表达式之后，它就毁灭了，充分利用资源，才能很高效。

当类中同时包含拷贝构造函数和移动构造函数时，如果使用临时对象初始化当前类的对象，编译器会优先调用移动构造函数来完成此操作。只有当类中没有合适的移动构造函数时，编译器才会退而求其次，调用拷贝构造函数。

std::move()

对于一个左值，肯定是调用拷贝构造函数了，但是有些左值是局部变量，生命周期也很短，能不能也移动而不是拷贝呢？C++11为了解决这个问题，提供了std::move()方法来将左值转换为右值，从而方便应用移动语义。其实就是告诉编译器，虽然我是一个左值，但是不要对我用拷贝构造函数，而是用移动构造函数。std::move 的源码实现：

1
2
3
4
5
6
7
8
9

// FUNCTION TEMPLATE move
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
    return static_cast<remove_reference_t<_Ty>&& >(_Arg);
}
//_NODISCARD 这是一种标记，用于指示编译器在忽略函数返回值时发出警告。
//constexpr:表示这个函数是在编译时计算的
//noexcept:表示这个函数不会抛出异常
//remove_reference_t 是 C++ 标准库 <type_traits> 中的一个模板元函数，用于移除类型的引用修饰符（& 或 &&）。

static_cast:

用于显示类型转换.在编译时进行类型检查，用于在不同但相关的类型之间检查.

其他类型转换的函数

• dynamic_cast:
  • 用于在运行时进行安全的向下转型，主要用于处理继承关系中的多态类型
  • 仅在具有虚函数的类层次结构中才有效
  • 如果转型合法，则返回目标类型的指针或引用，否则返回nullptr
• reinterpret_case：
  • 执行底层的二进制位级别的转换
  • 非常强大，但潜在的不安全，因为它可以忽略类型之间的语义差异

可以看到 std::move 是一个模板函数，通过remove_reference_t获得模板参数的原本类型，然后把值转换为该类型的右值。用C++大师 Scott Meyers 的在《Effective Modern C++》中的话说， std::move 是个cast ，not a move.

注意： 使用 move 意味着，把一个左值转换为右值，原先的值不应该继续再使用（承诺即将废弃）。

1
2
3
4
5
6
7
8
9
10
11

MiniString str1("hello"); // 调用构造函数
MiniString str2("world"); // 调用构造函数
MiniString str3(str1);    // 调用拷贝构造函数
MiniString str4(std::move(str1));    // 调用移动构造函数
// cout << str1.get_c_str() << endl; // 此时str1的内部指针已经失效了！不要再使用
// 虽然str1中的m_dat已经称为了空，但是str1这个对象还活着，知道出了它的作用域才会析构，
// 而不是move完了立刻析构
MiniString str5;
str5 = str2;            // 调用拷贝赋值函数
MiniString str6;
str6 = std::move(str2); // 调用移动赋值函数，str2的内容也失效了，不要再使用

要注意一下几点：

1. str6 = std::move(str2)，虽然将str2的资源给了str6，但是str2并没有立刻析构，只有在str2离开了自己的作用域的时候才会析构，所以，如果继续使用str2的m_data变量，可能会发生意想不到的错误。
2. 如果我们没有提供移动构造函数，只提供了拷贝构造函数，std::move()会失效但是不会发生错误，因为编译器找不到移动构造函数就去寻找拷贝构造函数，也这是拷贝构造函数的参数是const T&常量左值引用的原因！
3. c++11中的所有容器都实现了move语义，move只是转移了资源的控制权，本质上是将左值强制转化为右值使用，以用于移动拷贝或赋值，避免对含有资源的对象发生无谓的拷贝。move对于拥有如内存、文件句柄等资源的成员的对象有效，如果是一些基本类型，如int和char[10]数组等，如果使用move，仍会发生拷贝（因为没有对应的移动构造函数），所以说move对含有资源的对象说更有意义。

通用引用

当右值引用和模板结合的时候，就复杂了。T&&并不一定表示右值引用，它可能是个左值引用又可能是个右值引用。例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

template <class T>
void func(T&&a,T&&b)
{
    cout << a+b << endl;
}

int main()
{
    int a=10;
    int b=20;
    func(a,b);
    func(200,300);
    return 0;
}

如果上面的函数模板表示的是右值引用的话，肯定是不能传递左值的，但是事实却是可以。这里的&&是一个未定义的引用类型，称为universal references，它必须被初始化，它是左值引用还是右值引用却决于它的初始化，如果它被一个左值初始化，它就是一个左值引用；如果被一个右值初始化，它就是一个右值引用。

注意：只有当发生自动类型推断时（如函数模板的类型自动推导，或auto关键字），&&才是一个universal references

1
2

template <typename T>
void func(T&&a);//这里T需要推导，所以&&是universal references

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

template <class T>
class Person
{
public:
    Person(T age)
    {
        m_age = age;
    }
    T m_age;
};

int main()
{
    Person<int> p(1);
    cout <<p.m_age << endl;
    return 0;
}

template<typename T>
class Test {
  Test( Test&& rhs );   // Test是一个特定的类型，不需要类型推导，所以&&表示 右值引用  
};

1
2

template <typename T>
void func(std::vector<T>&& data);//在往vector添加元素的时候已经将T推断出来，所以是右值引用

所以最终还是要看T被推导成什么类型，如果T被推导成了string，那么T&&就是string&&，是个右值引用，如果T被推导为string&，就会发生类似string& &&的情况，对于这种情况，c++11增加了引用折叠的规则，总结如下：

1. 所有的右值引用叠加到右值引用上仍然使一个右值引用。
2. 所有的其他引用类型之间的叠加都将变成左值引用。

完美转发

所谓转发，就是通过一个函数将参数继续转交给另一个函数进行处理，原参数可能是右值，可能是左值，如果还能继续保持参数的原有特征，那么它就是完美的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

#include <iostream>
using namespace std;

void process(int &i)
{
    cout << "process(int &)" << i << endl;
}

void process(int &&i)
{
    cout << "process(int &&)" << i << endl;
}

void myforward(int &&i)
{
    cout <<"myforward(int &&)" << i << endl;
    //process(i);
    process(forward<int>(i));
}

int main()
{
    int a =0;
    process(a);
    process(1);
    process(move(a));
    myforward(1);
    myforward(move(a));
    return 0;
}

上面的例子就是不完美转发，而c++中提供了一个std::forward()模板函数解决这个问题。将上面的myforward()函数简单改写一下：

上面修改过后还是不完美转发，myforward()函数能够将右值转发过去，但是并不能够转发左值，解决办法就是借助universal references通用引用类型和std::forward()模板函数共同实现完美转发。例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

void RunCode(int &&m) {
    cout << "rvalue ref" << endl;
}
void RunCode(int &m) {
    cout << "lvalue ref" << endl;
}
void RunCode(const int &&m) {
    cout << "const rvalue ref" << endl;
}
void RunCode(const int &m) {
    cout << "const lvalue ref" << endl;
}

// 这里利用了universal references，如果写T&，就不支持传入右值，而写T&&，既能支持左值，又能支持右值
template<typename T>
void perfectForward(T && t) {
    RunCode(forward<T> (t));
}

template<typename T>
void notPerfectForward(T && t) {
    RunCode(t);
}

int main()
{
    int a = 0;
    int b = 0;
    const int c = 0;
    const int d = 0;

    notPerfectForward(a);       // lvalue ref
    notPerfectForward(move(b)); // lvalue ref
    notPerfectForward(c);       // const lvalue ref
    notPerfectForward(move(d)); // const lvalue ref

    cout << endl;
    perfectForward(a);       // lvalue ref
    perfectForward(move(b)); // rvalue ref
    perfectForward(c);       // const lvalue ref
    perfectForward(move(d)); // const rvalue ref
}

原文链接

This blog will be used by the Release Team for communally maintained projects which need a release announcement.

KDE Frameworks, Plasma and KDE Gear will remain on kde.org. But individual releases of apps and libraries which get their own releases can be announced here.

Ruqola 2.1.1 is a bugfix release of the Rocket.chat app.

Improvements:

• Preview url fixed
• I implement "block actions" (it's necessary in RC 6.6.x when we invite user)
• Fix OauthAppsUpdateJob support (administration)
• Fix update view when we translate message (View was not updated in private channel)
• Show server icon in combobox server
• Fix show icon for displaying emoji popup menu when we display thread message
• Fix jitsi support
• Fix dark mode

URL: https://download.kde.org/stable/ruqola/
Source: ruqola-2.1.1.tar.xz
SHA256: 6f089271ef9f2f576aa31ddc404bdbc8ddd5ddecba3cd9ff829641123bceb0ae
Windows Build: ruqola-2.1.1-windows-cl-msvc2022-x86_64.exe
Signed by: E0A3EB202F8E57528E13E72FD7574483BB57B18D Jonathan Esk-Riddell jr@jriddell.org https://jriddell.org/esk-riddell.gpg

If you have not been following this blog series, I made a wrapper for Firefox to be able to run different tabs (and more) in different KDE Plasma Activities.

Often a hurdle to using a piece of software is that it is not packaged for Linux distros.

Kudos to Aurélien Couderc (coucouf), who packaged already 0.4.1 for Debian and provided the patch to make it easier to package to different distros.

With 0.4.2 version of Activity-aware Firefox we applied that patch. Other then that, the functionality remains the same as in 0.4.1.

Then I also wrote an AUR package, so Arch, EndeavourOS etc. should be covered now too.

As a consequence, Repology now lists 12 distro packages for Activity-aware Firefox – that is a great start!

But while large, Debian- and Arch-based distros are just a subset of all available FOSS operating systems that KDE Plasma and Firefox run on. If someone were to put it on Open Build Service to cover also RPM-based and other distros, that would be a great boon!

Contributions welcome, as I am reaching the limit of my skills here.

hook out → server migration successful – more on that some other day

生成个人访问令牌

生成secrets前首先要生成个人访问令牌

创建令牌

1. 验证您的电子邮件地址(尚未验证)
2. 在任何界面的右上角，点击个人资料照片，点击设置
3. 在左边侧边栏中，点击Developer settings(在最下边)
4. 然后在Personal access tokens的Tokens中选择Generate new tokens然后选择第二个

选则您要授予此令牌的范围或权限。要使用令牌从命令行访问存储库，请选择repo。如果还需要其他权限请自行勾选。(workflow也进行选择)，然后确定即可

最后

将令牌复制到剪切板。出于安全的原因，在您离开该界面后，您将无法再次看到该令牌。

配置github项目的secrets

在github的仓库中打开设置。

在侧边栏中点击Secrets and variables中的Actions。

点击New repository secret。

名称是随便起得。Secret就是刚才生成的令牌.

详细教程

更改该仓库的写权限

在该仓库侧边栏中选择Actions当中的General,在该页面下的Workflow当中选择第一个并前保存.

详细教程 

设置贪吃蛇

在仓库中的Actions中点击newworkflow

然后点击set up a workflow yourself

新建snake.yml.

复制以下内容.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

name: generate animation

on:
  # run automatically every 24 hours
  schedule:
    - cron: "0 */24 * * *" 
  
  # allows to manually run the job at any time
  workflow_dispatch:
  
  # run on every push on the master branch
  push:
    branches:
    - main
    
  

jobs:
  generate:
    runs-on: ubuntu-latest
    timeout-minutes: 10
    
    steps:
      # generates a snake game from a github user (<github_user_name>) contributions graph, output a svg animation at <svg_out_path>
      - name: generate github-contribution-grid-snake.svg
        uses: Platane/snk/svg-only@v3
        with:
          github_user_name: ${{ github.repository_owner }}
          outputs: |
            dist/github-contribution-grid-snake.svg
            dist/github-contribution-grid-snake-dark.svg?palette=github-dark
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
          
          
      # push the content of <build_dir> to a branch
      # the content will be available at https://raw.githubusercontent.com/<github_user>/<repository>/<target_branch>/<file> , or as github page
      - name: push github-contribution-grid-snake.svg to the output branch
        uses: crazy-max/ghaction-github-pages@v3.1.0
        with:
          target_branch: output
          build_dir: dist
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

然后保存.

然后点击Run workflow即可

然后回到该仓库的主页，会生成output分支，里面会有对应提交记录的贪吃蛇的svg图片

然后点击生成的文件，在右上角有Raw，即可查看文件地址.

贪吃蛇详细教程

个人readme文件

将贪吃蛇部分代码部分代码的链接进行替换。

C++初始

1.编写C++程序步骤

• 创建项目
• 创建文件
• 编写代码
• 运行程序

1.3变量

作用：给一段指定的内存空间起名，方便操作这段内存

语法：数据类型 变量名 =初始值

1.5关键字

预先保留的单词

在定义变量或者常量的时候，不要用关键字

标识符命名规则

• 标识符不能是关键字

• 标识符只能由字母，数字，下划线组成

• 第一个字符必须为字母或者下划线

• 标识符中区分大小写

  给标识符命名时，争取做到见名知意的效果，方便阅读

数据类型

实型

作用：用于表示小数

浮点型变量分为两种：

1. 单精度float
2. 双精度double

两者的区别在与表示的有效数字范围不同.

也可以用科学计数法表示.

字符型

作用：字符型变量用于显示单个字符

语法：char ch = 'a';

注意1：在显示字符型变量时，用单引导将字符括起来，不要用双引号

注意2：单引号内只能有一个字符，不可以是字符串

字符串型

1
2
3
4
5

//c风格的字符串
char str[]="helloworld";
//c++风格的字符串
//要包含头文件
string str="helloworld";

布尔类型

本质上1代表真，0代表假

占一个字节.

数据的输入

关键字cin

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//整形
int a =0;
cout << "请输入整形变量:" << endl;
cin >> a;
cout << a << endl;

//浮点型
double a =0;
cout << "请输入浮点型变量:" << endl;
cin >> a;
cout << a << endl;

//字符型
char a =0;
cout << "请输入字符型变量:" << endl;
cin >> a;
cout << a << endl;

//字符串型
string a =0;
cout << "请输入字符串型变量:" << endl;
cin >> a;
cout << a << endl;

小数间是不能做取模运算的

程序流程结构

c/c++支持最基本的三种程序运行结构：顺序结构、选择结构、循环结构

• 顺序结构：程序按顺序执行，不发生跳转
• 选择结构：依据条件是否满足，有选择的执行相应功能
• 循环结构：依据条件是否满足，循环多次执行某段代码

跳转语句

break语句

作用：用于跳出选择结构或者循环结构

break使用的时机：

• 出现在switch条件语句中，作用是终止case并跳出switch
• 出现在循环语句中，作用是跳出当前的循环语句
• 出现在嵌套循环中，跳出最近的内存循环语句

continue 语句

作用：在循环语句中，跳出本次循环中余下尚未执行的语句，继续执行下一次循环

函数

作用：将一段经常使用的代码封装起来，减少重复的代码

函数的定义一般主要有5步骤：

1. 返回值类型
2. 函数名
3. 参数列表
4. 函数体语句
5. return 表达式

指针

空指针：指针变量指向内存中编号为0的空间

用途：初始化指针变量

注意：空指针指向的内存是不可以访问的

结构体

核心编程

内存分区模型

• 代码区 存放CPU执行的机器指令 共享 只读

• 全局区

  局部变量、const修饰的局部变量(局部变量)	不在全局区中
  全局变量 静态变量 static关键字 常量	全局区

• 栈区

  不要返回局部变量的地址

• 堆区

  在c++中主要利用new在堆区开辟内存

意义：不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程

堆区

​C++中利用new操作符在堆区开辟数据

堆区开辟的数据由程序员手动开辟、手动释放、释放利用操作符delete

语法：new 数据类型

利用new创建的数据，会返回该数据对应的类型的指针

new的基本语法

1

int *a=new int(10);

引用

作用：给变量起别名

语法：数据类型 &别名 =原名

注意事项

• 引用必须要初始化
• 引用一旦初始化后，就不可以更改

引用可以简化指针的用法.

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

通过引用参数产生的效果按地址传递是一样的。引用的语法更加的简单。

引用是可以作为函数的返回值存在的.

不返回局部变量的引用.

函数的调用可以作为左值.

1
2
3

int &ref2=test02();

test02()=1000;

本质：引用的本质在c++内部实现是一个指针常量.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

void func(int &ref)
{
    ref=100;
}

int main()
{
int a=10;
    //自动转换为int *const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可以改
    int &ref=a;
    ref=20;
    
    func(a);
    return 0;
}

引用必须引一块合法的内存空间。

const修饰的局部变量不再全局区.

函数

函数默认参数

在c++中，函数的形参列表中的形参是可以有默认值的

语法 ：返回值类型 函数名 （参数= 默认值） {}

1
2
3
4
5
6

int func(int a,int b=10,int c=10)
{
return a+b+c;
}
//1.如果某个位置参数有默认值，那么这个位置往后，从左向右，必须都要有默认值
//2.如果函数声明有默认值，函数实现的时候就不能有默认值

函数的默认参数，如果我们传入了参数，值就使用我们传入的参数，如果我们没有传入参数，那么就使用函数的默认参数值

注意事项：

• 如果某个位置已经有了默认参数，那么这个位置往后，从左到右都必须要有默认值
• 如果函数声明有默认参数，函数实现就不能有默认参数
• 声明和实现只能一个有默认参数

函数占位参数

c++中的函数的形参列表可以有占位参数，用来做占位，调用函数时必须填补该位置

语法：返回值类型 函数名 （数据类型） { }

目前占位参数我们还用不到.

占位参数还可以有默认参数.

函数重载

作用：函数名可以相同，提高复用性

满足条件

• 同一个作用域下
• 函数名称相同
• 函数参数类型不同 或者 个数不同 或者顺序不同

注意事项：

• 函数的返回值不可以作为函数重载的条件

• 引用作为重载的条件

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

  void fun(int &a)//这两个可以作为函数重载的条件，因为函数的参数类型不同 { cout << "func(int &a)调用" <<endl; } void fun(const int &a) { cout << "func(const int &a)调用"<<endl; } int main() { int a=10; func(a);//调用的是第一个，因为这是一个变量. int func(10);//调用的是第二个。 return 0; }

• 函数重载碰到默认参数(会出现二义性，尽量避免使用)

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

  void func2(int a) { cout << "func2(int a)的调用" <<endl; } void func2(int a,int b=10) { cout << "func2(int a,int b)的调用" <<endl; } int main() { func2(10); return 0; }

类和对象

c++面向对象的三大特性为：封装、继承、多态

c++认为万事万物都皆为对象，对象上有其属性和行为

具有相同性质的对象，我们可以抽象称为类，人属于人类，车属于车类

封装

意义

封装是c++面向对象的三大特性之一

• 将属性和行为作为一个整体，表现生活中的事物
• 将属性和行为加以权限控制

封装意义1：

在设计类的时候，属性和行为写在一起，表示事物

语法：class 类名 { 访问权限 ： 属性 /行为 }；

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

const double PI =3.14;
class Circle 
{
    //访问权限
public:
    //圆的属性
    int m_r;
    //行为
    //获取周长
    double calculateZC()
    {
        return 2*PI*m_r;
}
}

int main()
{
//通过圆类 创建具体的圆（对象）
    //实例化(通过一个类  创建一个对象的过程) 
    Circle c1;
    //给圆对像的属性进行赋值、
    c1.m_r=10 ;
    cout << c1.calculateZC()<<endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

class Student//设计学生类
{
    public ://公共权限
    //类中的属性和行为  我们统称为 成员
    //属性 也成为 成员属性 成员变量
    //行为 也称为 成员函数 成员方法
    //属性 
    string m_Name;
    int m_Id;
    //行为
    void show()
    {
        cout<<"姓名：  " << m_Name << "学号 :" << m_Id<<endl;
    }
    void set_name(string name)
    {
        m_Name=name;
}
    void set_Id(int id)
    {
        m_Id=id;
    }
}

int main()
{
    Student s1;
    cin>>s1.m_Name>>m_Id;
    s1.show();
    Student s1;
    s2.set_name("张三");
    s2.set_Id(1);
    return 0;
}

封装意义二：

类在设计时，可以把属性和行为放在不同的权限下，加以控制

三种权限：

1.public 公共权限

2.protected 保护权限

3.private私有权限

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//访问权限 三种
//公共权限public成员 类内可以访问 类外也可以访问
//保护权限protected成员 类内可以访问 类外不可以访问
//私有权限private成员 类内可以访问 类外不可以访问
//私有权限与保护权限的区别 在继承的时候可以区分 儿子可以访问父亲中的保护内容
//儿子不可以访问父亲的私有内容
class Person
{
public:
string m_Name;
protected:
    string m_Car;
private:
    int m_Password;
public:
    void func()
    {
        m_Name="张三";
        m_Car="饿狼传说"；
        m_Password=123145;
}
};

class 和 struct 的区别

在c++中struct 和 class 唯一的区别就在于默认的访问权限不同

区别：

• struct默认权限为公共
• class 默认权限为私有

成员属性设置为私有

优点：

• 将所有成员属性设置为私有，可以自己控制读写权限
• 由于写权限，我们可以检测数据的有效性

在类中可以让另外一个类作为类中本来的成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Point
{
    public:
    //在此实现成员函数
    private:
    int m_X;
    int m_Y;
}
class circle
{
    public:
    //在此实现成员函数
    private:
    int m_R;
    Point m_Center;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

//在头文件中可以进行类的声明
class Point
{
    public:
    void setx(int x);
    void sety(int y);
    private:
    int m_X;
    int m_Y;
}

class Circle
{
    public:
    void setm_R(int r);
    int getr();
    private:
    int m_R;
    Point Center;
}
//在其余的文件定义该函数的时候需要加作用域
void Point:: setx(int x)
{
    m_X=x;
}

对象的初始化清理

c++中的面向对象来源于生活 ，每个对象也都会有初始设置 以及对象销毁前的清理数据的设置。

构造函数和析构函数

对象的初始化和清理也是两个非常重要的安全问题

​一个对象或者变量没有初始状态，对其使用后果未知

​同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会给我们提供空实现

构造函数语法： 类名(){}

1. 构造函数，没有返回值也不写void
2. 函数名称与类名相同
3. 构造函数可以有参数，因此可以发生重载
4. 程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

析构函数语法： ~类名(){}

1. 析构函数，没有返回值也不写void
2. 函数名称与类名相同，在名称前加上符号~
3. 析构函数不可以有参数，因此不可以发生重载
4. 程序在对象销毁前自动调用析构，无需手动调用，而且只会调用一次

构造函数的分类及调用：

• 按参数

  • 有参构造
  • 无参构造

• 按类型

  • 普通构造
  • 拷贝构造

三种调用方法：

• 括号法

  1 2 3

  Person P;//默认构造时后面不要加括号 Person p1(10); Person p2(p1);

• 显示法

  1 2 3

  Person p; Person p1=Person(10); Person P2=Person(p2);

• 隐式转换法

  1 2	Person p4=10; Person p5=p4;

构造函数的调用顺序:

1.当普通构造一个对象时，程序先自动调用默认构造函数分配空间，在调用自定义构造函数(如果有的话)

2.当拷贝构造一个对象时，程序先自动调用默认构造函数分配空间，然后分两种情况，如果程序有自定义拷贝函数，则调用自定义拷贝构造函数；如果没有，就调用默认拷贝构造函数进行浅拷贝.

拷贝构造函数调用时机

c++拷贝构造函数调用时机

• 使用一个创建完毕的对象来初始化一个新对象
• 值传递的方式给函数参数传值(做参数)
• 以值的方式返回局部对象(做返回值)

构造函数调用规则

默认情况下，c++编译器至少给一个类添加3个函数

1.默认构造参数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性值进行拷贝

规则如下：

• 如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
• 如果用户定义拷贝构造函数，c++不会在提供其他的构造函数

深拷贝与浅拷贝

浅拷贝：简单的赋值操作

深拷贝：在堆区重新申请空间，进行拷贝操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

class Person
{
    public:
    Person()
    {
        cout << "Person" << endl;
    }
    Person(int a,int height)
    {
        m_age =a;
        m_height= new int(height);
    }
    Person(const Person &other)
    {
        cout << "Personkb" << endl;
        m_age = other.m_age;
        m_height =new int(*other.m_height);//深拷贝
    }
    ~Person()
    {
        //析构，将堆区开辟的空间做释放操作
        if(m_height !=NULL)
        {
            delete m_height;
        }
        cout << "Personxg" << endl;
    }
    int m_age;
    int *m_height; 
};

void test01()
{
    Person p1(18,160);
    cout << p1.m_age << endl;
    cout << *p1.m_height << endl;
    Person p2(p1);
    cout << p2.m_age << endl;
    cout << *p2.m_height <<endl;//会发生错误，因为p2是浅拷贝，但析构函数内部对p2进行了释放
}

int main()
{
    test01();
    return 0;
}

会出现:free():double free detected in tcache 2.

编译起提供的拷贝构造函数，只是简单的赋值，将原先的地址在复制一份。

所以需要深拷贝来解决该问题，自己实现拷贝构造函数

初始化列表

作用：c++提供了初始化列表语法，用来初始化（类的）属性

语法：构造函数( ): 属性1(值1),属性2(值2) ... {}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

class Person
{
public:
    //Person(int a,int b,int c)
    //{
    //m_A=a;m_B=b;m_C=c;
//}
    Person(int a,int b,int c):m_A(a),m_B(b),m_C(c)
    {
        
    }
    int m_A;
    int m_B;
    int m_C;
}
void test
{
    Person p;
}

int main()
{
    test();
    return 0;
}

初始化const成员变量的唯一方法就是使用初始化列表

类对象作为类成员

c++类中的成员可以是另一个类的对象，我们称该成员为对象成员

1
2
3
4
5

class A{}
class B
{
    A a;
}//B类中有对象A作为成员，A为对象成员

那么当创建B对象时，A与B的构造和析构的顺序是谁先谁后？

先构造A对象.

当其他类的对象作为本类成员，构造时先构造类对象，在构造自身.

先析构B对象

析构时先析构自身，在析构类对象.

静态成员

静态成员就是在成员变量和成员函数前加上关键字static，成为静态成员

• 静态成员变量

  • 所有对象共享同一份数据
  • 在编译阶段分配内存
  • 类内声明，类外初始化

• 静态成员函数

  • 所有对象共享一个函数
  • 静态成员函数只能访问静态成员变量,不可以访问非静态成员变量
    • 无法区分到底是哪一个对象的属性
    • 也是有访问权限的

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class Person
{
Public:
    static int m_A;
}

int Person:: m_A=100;

void test()
{
Person P;
    cout << P.m_A <<endl;//100
    Person p2;
    p2.m_A=200;
    cout << P.m_A <<endl;//200
}

void test02()
{
    cout <<Person :: m_A <<endl;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class Person
{
public:
    static void func()
    {
        cout << "static" << endl; 
    }
};

void test()
{
   Person ::func();
}

int main()
{
    test();
    return 0;
}

c++对象模型和this指针

成员变量和成员函数分开存储

类的成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上

空对象的大小为1

c++编译器会给每一个空对象分配一个字节空间，是为了空对象占内存的位置.

每个空对象有一个独一无二的内存地址

this指针概念

每一个非静态成员函数只会诞生一份函数实例，也就是说多个同类型的对象会共用一块代码

那么问题是：这一块代码是如何区分那个对象调用自己的呢?

c++通过提供特殊的对象指针，this指针，解决上述问题.this指针指向被调用的成员函数所属的对象。

this指针是隐含每一个非静态的成员函数内的一种指针

this指针不需要定义，直接使用即可

用途：

• 当形参和成员变量名同名时，可用this指针来区分
• 在类的非静态成员函数中返回对象本身，可使用return *this

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

class Person
{
public:
    Person(int age)
    {
        //解决名称冲突
        this->age = age;
    }
    Person& PersonAddage(Person &P)//要返回引用， 如果返回的是Person的值话，返回的是对p2的一份拷贝
    {
        this->age += P.age;
        return *this;//返回*this
    }
    int age;
};

void test01()
{
    Person p1(18);
    cout << p1.age << endl;
}

void test02()//链式编程思想
{
    Person p1(10);
    Person p2(10);
    p2.PersonAddage(p1).PersonAddage(p1).PersonAddage(p1);
    cout << p2.age <<endl;
}

int main()
{
    test02();
    return 0;
}

空指针访问成员函数

c++中空指针也是可以调用成员函数的，但是也要注意有没有用到this指针

对this判空有助于提高代码的健壮性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

class Person
{
public:
    void showClassName()
    {
        cout << "Person" << endl;
    }
    void showPersonAge()
    {
        //报错原因是因为传入的指针是为NULL空的
        if(this==NULL) return;
        cout << "age=" << m_Age << endl;
    }
    int m_Age;
};

void test01()
{
    Person *P=NULL; 
    P->showClassName();
    // P->showPersonAge();
}

int main()
{
    test01();
    return 0;
}

const修饰成员函数

常函数：

• 成员函数后加const后我们称这个函数为常函数
• 常函数内不可以修改成员属性
• 成员属性声明时加关键字mutable后，在常函数中依然可以修改

常对象：

• 声明对象前加const称该对象为常对象
• 常对象只能调用常函数
  • 普通成员函数可以修改属性

1
2
3
4
5
6

//this指针的本质 是指针常量  指针的指向是不可以修改的
//const Person *const this
void showPerson()const
{
this->m_A =100;
}

在成员函数后面加const，修饰的是this指向，让指针指向的值也不可以修改.

友元

在程序里，有些私有属性，也想让类外特殊的一些函数或者类进行访问，就需要用到友元的技术

友元的目的就是一个函数或者类 访问另一个类中私有成员

友元的关键字：friend

友元的三种实现

• 全局函数做友元

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27

  class Building { //goodGay全局函数是 BUilding好朋友 ，可以访问Building中私有成员 friend void goodGay(Building &building); public: Building() { m_SittingRoom ="客厅"; m_BedRoom = "卧室"; } public: string m_SittingRoom; private: string m_BedRoom; }; void goodGay(Building &building) { cout << building.m_SittingRoom << endl; cout << building.m_BedRoom << endl; } void test01() { Building building; goodGay(building); }

• 类做友元

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45

  class Building { //goodGay类是本类的好朋友，可以访问本类中的私有成员 friend class goodGay; public: Building(); public: string m_SittingRoom; private: string m_BedRoom; }; class goodGay { public: goodGay(); void visit();//参观函数访问Building中的属性 Building *building; }; goodGay::goodGay() { building = new Building; } void goodGay:: visit() { cout<<building->m_SittingRoom<<endl; cout<<building->m_BedRoom<<endl; } //类外去写成员函数 Building::Building() { m_SittingRoom = "客厅"; m_BedRoom = "卧室"; } void test01() { goodGay g; g.visit(); }

• 成员函数做友元

  1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49

  class Building; class goodGay { public: goodGay(); void visit1();//visit可以访问私有成员 void visit2();//不可以访问私有成员 Building *building; }; class Building { friend void goodGay::visit1(); public: Building(); public: string m_SettingRoom; private: string m_BedRoom; }; Building :: Building() { m_SettingRoom = "客厅"; m_BedRoom = "卧室"; } goodGay :: goodGay() { building = new Building; } void goodGay :: visit1() { cout << "Building " << building->m_SettingRoom <<endl; cout << "Building " << building->m_BedRoom <<endl; } void goodGay :: visit2() { cout << "Building " << building->m_SettingRoom <<endl; } void test() { goodGay g; g.visit1(); g.visit2(); }

运算符重载

元算符重载概念：对已有的运算符重新进行定义，赋予其另外一种功能，以适应不同的数据类型

加号运算符重载

作用：实现两个自定义数据类型相加的运算

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

Person p3=p1.operator+(p2);
简化为
Person p3=p1+p2;
class Person
{
public:
    // Person operator+(Person &p)
    // {
    //     Person temp;
    //     temp.m_A=this->m_A+p.m_A;
    //     temp.m_B=this->m_B+p.m_B;
    //     return temp;
    // }
    //本质上的调用是 Person p3=p1.operator+(p2);
    int m_A;
    int m_B;
};

Person operator+(Person &p1,Person &p2)//本质上调用是Person p3=operator+(p2,p1);
{
    Person temp;
    temp.m_A=p1.m_A+p2.m_A;
    temp.m_B=p1.m_B+p2.m_B;
    return temp;
}

void test()
{
    Person p1;
    p1.m_A = 10;
    p1.m_B = 10;
    Person p2;
    p2.m_A = 10;
    p2.m_B = 10;
    Person p3=p1+p2;
    cout << p3.m_A << endl;
    cout << p3.m_B << endl;
}

运算符重载也可以发生函数重载.

总结：

• 对于内置的数据类型的表达式的运算符是不可能改变的
• 不要滥用运算符重载

左移运算符重载

可以输出自定义的数据类型

通常不会利用成员函数重载<<运算符，因为无法实现cout在左侧

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

class Person
{
public:
    // 通常不会利用成员函数重载<<运算符，因为无法实现cout在左侧
    // void operator<<()
    // {
    // }
    int m_A;
    int m_B;
};

//只能全局函数来重载左移运算符
ostream& operator<<(ostream &cout,Person &p)
{  
    cout << "m_A=" << p.m_A <<endl;
    cout << "m_B=" << p.m_B <<endl;
    return cout;
}

void test()
{
    Person p;
    p.m_A = 10;
    p.m_B = 10;
    cout << p<<endl;
    cout << p.m_A << " " << p.m_B << endl;
}

重载左移运算符可以配合友元实现输出自定义数据类型

递增运算符重载

作用：通过重载运算符，实现自己的整形数据

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

class MyIntegar
{
    friend ostream& operator<<(ostream& os,  MyIntegar s);
public:
    MyIntegar()
    {
        m_Num = 0;
    }
    //重载前置++运算符
    MyIntegar& operator++()
    {
        m_Num++;
        return *this;
    }
    MyIntegar operator++(int)//int代表占位参数，可以用于区分前置和后置递增
    {
        MyIntegar temp=*this;
        this->m_Num++;
        return temp;
    }
private:
    int m_Num;
};

ostream& operator<<(ostream& os,  MyIntegar s)
{
    os << s.m_Num ;
    return os;
}

void test()
{
    MyIntegar myint;
    cout << ++(++myint)<<endl; 
    cout << myint << endl;
}

void test2()
{
    MyIntegar myint;
    cout << myint++<<endl; 
    cout << myint << endl;
}

赋值运算符重载

c++编译器至少给一个类添加4个函数

1.默认构造函数(无参，函数体为空)

2.默认析构函数(无参，函数体为空)

3.默认拷贝构造函数，对属性进行值拷贝

4.赋值运算符 operator=,对属性进行值拷贝

如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

class Person
{
public:
    Person(int age)
    {
        m_Age = new int(age);
    }
    Person& operator=(Person &p)
    {
        //应该先判断是否有属性在堆区，如果有先释放干净，然后在深拷贝
        if(m_Age !=NULL)
        {
            delete m_Age;
        }
        m_Age= new int(*(p.m_Age));
        return *this;
    }
    ~Person()
    {
        if(m_Age!=NULL)
        {
            delete m_Age;
            m_Age = NULL;
        }
    }
    int *m_Age;
};

void test()
{
    Person p1(18);
    Person p2(20);
    Person p3(30);
    p3=p2=p1;
    cout << *p1.m_Age << endl;
    cout << *p2.m_Age << endl;
    cout << *p3.m_Age << endl;
}   

关系运算符重载

作用：重载关系运算符，可以让两个自定义类型对象进行对比操作

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

class Person
{
public:
    Person(string name,int age)
    {
        m_Name=name;
        m_Age=age;
    }
    bool operator==(Person &P)
    {
        if(this->m_Name==P.m_Name && this->m_Age==P.m_Age)
        {
            return true;
        }
        return false;
    } 
     bool operator!=(Person &P)
    {
        if(this->m_Name==P.m_Name && this->m_Age==P.m_Age)
        {
            return false;
        }
        return true;
    } 
    string m_Name;
    int m_Age;
};

void test()
{
    Person p1("John",18);
    Person p2("John",18);
    if(p1 == p2)
    {
        cout << "p1==p2" << endl;
    }
    else
    {
        cout << "p1!=p2" << endl;
    }
}

函数调用运算符重载

• 函数调用运算符()也可以重载
• 由于重载后使用的方式非常像函数的调用，因此称为仿函数
• 仿函数没有固定写法，非常灵活

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Myprint
{
public:
    //重载函数调用运算符
    void operator()(string test)
    {
        cout << test << endl;
    }
};

void test()
{
    Myprint Myprint;
    Myprint("helloworld");
}