C++开发中用到的一些概念~

最新推荐文章于 2022-10-23 22:26:50 发布

AWildPointer

最新推荐文章于 2022-10-23 22:26:50 发布

阅读量261

点赞数 2

分类专栏： C++

本文链接：https://blog.csdn.net/m0_37668446/article/details/118864354

版权

C++ 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

记录开发过程中遇到的一些实际的问题：

1回调的几种方式(可调用对象，不仅仅是函数)

1.1回调

表现：比如UI上buttom触发，我们需要调用相关函数处理逻辑，也就是说把函数作为一个参数传进函数。

例子：STL库中的sort

void stable_sort(vector<string>::iterator iterBegin, vector<string>::iterator iterEnd, 
bool (*isShorter)(const string &, const string &))；

isShorter 在传递的时候，只需要写名字，其代表一个函数指针。

回调的含义：在调用时，必须把两个单词传递给isShorter供其r调用。所以说stable_sort调用了myIsShorter，而myIsShorter又调用了stable_sort给它的单词。它们相互调用。这就是“回调”这两个字的含义！参考

TIPS:这里虽然实参（函数）变了，但是事实上实参（函数）的数据类型不能变。函数的数据类型由（返回值类型、参数类型）决定。

事实上，回调函数就是把函数当作参数使用，使得程序更具有普适性。

其实虚函数的继承也可以实现

1.2lamda表达式（回调参数匹配）

表现：回调函数对于参数有限制，必须一样，我们想多传递一个参数进去，原来的就不行了。

是一个匿名类，上面说了，回调函数类型需要数据类型不变，那么有时候我们想让回调函数多一个参数，就需要使用lamda表达式了。
其格式为：

[capture list](parameter list)->return type{function body}

其中，参数列表和返回类型都可以省略。捕获列表也可以为空，但是[ ]必须写上。

匿名函数除了没有函数名之外，比传统函数多了一个capture list，捕获对象和参数的区别在于，捕获对象的值在程序运行到lambda表达式之前就已经确定了。而参数的值在运行到lamdba表达式之前是不确定的。

void fun()
{
      int i=1;
      int j=2;
 
      funcA(i, [j](int k){return k>j;});
}

可以看出，其实程序运行到funcA的时候，匿函数调函数列表的k 回调i，然后j是实现已经确定好的（捕获列表捕捉到的~），这样就可以实现传入两个。打破了上面一个的情况。

至此，解决回调函数的参数适配问题

1.3bind（lambda代码过长，也解决参数匹配问题）

bind函数的功能就是把多余的参数用实参代替，返回一个参数数目更少的新函数，以便新的函数能够作为回调函数被另一个函数调用。也就是实现了绑定，其实对于可调用对象都可以进行绑定。

auto  newCallable = bind(callable, arg_list);

其中callable就是原函数，arg_list就是callable的参数列表，不同参数之间用逗号隔开。arg_list允许包含占位符：_1, _2, _3等。占位符所处位置的参数就是新函数的参数。_1表示其所处位置的参数是新函数的第一个参数，_2表示第二个参数。例如

bool compare(int i, double j);
auto newFunc =bind(compare, 4, _1);

这里新的函数就是只有一个double型的参数，返回值为bool型。那么他就可以绑定i为4；

2 std::bind&&std::function（模板类）配合使用

2.1可调用对象

函数指针
有operator()成员函数的类的对象
可被转换成函数指针的类对象
类成员函数指针

可调用对象的形式固定，但是定义类型有很多。引入bind和function就能统一可调用函数的各种操作，如调用、传递等。

比如说

// 普通函数
int add(int a, int b){return a+b;} 

// lambda表达式
auto mod = [](int a, int b){ return a % b;}

// 函数对象类
struct divide{
    int operator()(int denominator, int divisor){
        return denominator/divisor;
    }
};

上面三个可调用对象虽然类型不一样，但是调用形式都是

int(int, int)

std::function可以将他们都存起来。

std::function<int(int ,int)>  a = add; 
std::function<int(int ,int)>  b = mod ; 
std::function<int(int ,int)>  c = divide();

所以可以看到，std::function是一个类模板

2.2std::function 取代函数指针

是一个类模板，可以容纳除了类成员函数指针之外的可调用对象
定义格式：std::function<函数类型>
std::function可以取代函数指针的作用，因为它可以延迟函数的执行，特别适合作为回调函数使用。它比普通函数指针更加的灵活和便利。

2.3std::bind 绑定部分参数

上面已经说了bind的作用，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
std::bind将可调用对象与其参数一起进行绑定，绑定后的结果可以使用std::function保存。

std::bind主要有以下两个作用：

将可调用对象和其参数绑定成一个仿函数
只绑定部分参数，减少传入的参数

2.3.1绑定普通函数

double my_divide (double x, double y) {return x/y;}
auto fn_half = std::bind (my_divide,_1,2);  
std::cout << fn_half(10) << '\n';                        // 5

2.3.2绑定一个引用参数

bind的那些不是占位符的参数被拷贝到bind返回的可调用对象中。但是，与lambda类似，有时对有些绑定的参数希望以引用的方式传递，或是要绑定参数的类型无法拷贝。

#include <iostream>
#include <functional>
#include <vector>
#include <algorithm>
#include <sstream>
using namespace std::placeholders;
using namespace std;

ostream & print(ostream &os, const string& s, char c)
{
    os << s << c;
    return os;
}

int main()
{
    vector<string> words{"helo", "world", "this", "is", "C++11"};
    ostringstream os;
    char c = ' ';
    for_each(words.begin(), words.end(), 
                   [&os, c](const string & s){os << s << c;} );
    cout << os.str() << endl;

    ostringstream os1;
    // ostream不能拷贝，若希望传递给bind一个对象，
    // 而不拷贝它，就必须使用标准库提供的ref函数
    for_each(words.begin(), words.end(),
                   bind(print, ref(os1), _1, c));
    cout << os1.str() << endl;
}

3注意：指向成员函数的指针的定义

#include <iostream>
struct Foo {
    int value;
    void f() { std::cout << "f(" << this->value << ")\n"; }
    void g() { std::cout << "g(" << this->value << ")\n"; }
};
void apply(Foo* foo1, Foo* foo2, void (Foo::*fun)()) {
    (foo1->*fun)();  // call fun on the object foo1
    (foo2->*fun)();  // call fun on the object foo2
}
int main() {
    Foo foo1{1};
    Foo foo2{2};
    apply(&foo1, &foo2, &Foo::f);
    apply(&foo1, &foo2, &Foo::g);
}

成员函数指针的定义：void (Foo::*fun)()，调用是传递的实参: &Foo::f；
fun为类成员函数指针，所以调用是要通过解引用的方式获取成员函数*fun,即(foo1->*fun)();

4闭包

函数是代码，状态是一组变量，将代码和一组变量捆绑 (bind) ，就形成了闭包。一个函数+一个状态
参考

实现可以通过重载operator()的类、lambda、bind()实现。

5多线程异步&&同步

5.1为什么可以多线程

多核CPU可以并行
单个CPU分片 1S的能力可以分成1000份，从宏观来看就是并行的。

同步发起调用，完成后才继续下一行；非常符合开发思维，有序执行。相互依赖
异步发起调用，不等待完成，直接进入下一行，启动一个新线程开完成方法的计算。相互独立

同步方法比较慢，因为只有一个线程计算，异步方法快，因为有多个线程并发计算。多线程其实就是用资源换性能。
== 同步方法有序进行，但是异步方法启动无序。因为线程资源是向操作系统申请的，由操作系统的调度决策决定，所以启动是无序的。同一个任务用一个线程，执行时间也是不确定的，是CPU分片导致的。==

并行：多核之间叫并行。
并发：CPU分片的并发。
回调：将后续动作通过回调参数传递进去，子线程完成计算后，去调用这个回调委托。

5.2future

6UML类图(静态结构图)

四大关系：

常见的关系有：
关联关系（Association） has a 里面有一个指针
继承（Inheritance） is a（虚函数和对象的继承）
实现关系(Realization/Implementation) is a
依赖关系（Dependency） use a
聚合关系（Aggregation） has a
复合关系（Composition） has a

在这里插入图片描述
百度百科

7常用的设计模式

单例

代理

https://blog.csdn.net/lh844386434/article/details/18045671

监听模式

在这里插入图片描述

1attach是连接
2detach 断开连接
3notify 通知

时序图
在这里插入图片描述



#include <iostream>
#include <list>

using namespace std;
class Observer{
public:
     virtual void Update(int) = 0;
};

 class Subject
{
public:
     virtual void Attach(Observer *) = 0;
     virtual void Detach(Observer *) = 0;
     virtual void Notify() = 0;
};

class ConcreteObserver : public Observer
{
public:
     ConcreteObserver(Subject *pSubject) : m_pSubject(pSubject){}
     void Update(int value)     {
          cout<<"ConcreteObserver get the update. New State:"<<value<<endl;
     }
private:
     Subject *m_pSubject;
};

class ConcreteObserver2 : public Observer
{
public:
     ConcreteObserver2(Subject *pSubject) : m_pSubject(pSubject){}
     void Update(int value){
          cout<<"ConcreteObserver2 get the update. New State:"<<value<<endl;
     }
private:
     Subject *m_pSubject;

};

class ConcreteSubject : public Subject
{
public:
     void Attach(Observer *pObserver);
     void Detach(Observer *pObserver);
     void Notify();
     void SetState(int state)
     {
          m_iState = state;
     }
private:
     std::list<Observer *> m_ObserverList;
     int m_iState;
};

void ConcreteSubject::Attach(Observer *pObserver)
{
     m_ObserverList.push_back(pObserver);
}

void ConcreteSubject::Detach(Observer *pObserver)
{
     m_ObserverList.remove(pObserver);
}


void ConcreteSubject::Notify()
{
     std::list<Observer *>::iterator it = m_ObserverList.begin();
     while (it != m_ObserverList.end())
     {
          (*it)->Update(m_iState);
          ++it;
     }
}

int main()
{
     // Create Subject
     ConcreteSubject *pSubject = new ConcreteSubject();

     // Create Observer
     Observer *pObserver = new ConcreteObserver(pSubject);
     Observer *pObserver2 = new ConcreteObserver2(pSubject);

     // Change the state
     pSubject->SetState(2);

     // Register the observer
     pSubject->Attach(pObserver);
     pSubject->Attach(pObserver2);
 
     pSubject->Notify();

     // Unregister the observer
     pSubject->Detach(pObserver);
 

     pSubject->SetState(3);
     pSubject->Notify();

     delete pObserver;
     delete pObserver2;
     delete pSubject;
}

使用场景
1.当一个抽象模型有两个方面，其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立的改变和复用；
2.当对一个对象的改变需要同时改变其它对象，而不知道具体有多少对象有待改变；
3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁；也就是说，你不希望这些对象是紧密耦合的。

https://www.jb51.net/article/55990.htm

观察者模式

工厂

抽象类->实际类(factory)->里面依赖另一个抽象类的子类（product）
链接

AWildPointer

关注

2
点赞
踩
1

收藏

觉得还不错? 一键收藏
2
评论
C++开发中用到的一些概念~

记录开发过程中遇到的一些实际的问题：1回调表现：比如UI上buttom触发，我们需要调用相关函数处理逻辑，也就是说把函数作为一个参数传进函数。例子：STL库中的sortvoid stable_sort(vector<string>::iterator iterBegin, vector<string>::iterator iterEnd, bool (*isShorter)(const string &, const string &))；isShort
复制链接

扫一扫