2021年06月_发如雪-ty

12月 11月 10月 09月 08月 07月 06月 05月 04月 03月 02月 01月

原创深度探索c++对象模型-04-手动调用虚函数（多态实现原理）

如何手动调用虚函数呢？下面直接看代码一、代码#include <iostream>class Father{public: virtual void Func1() { std::cout << "Fahter::Func1()" << std::endl; } virtual void Func2() { std::cout << "Fahter::Func2()" << std::endl; } virtual

2021-06-29 23:29:26 273 3

原创设计模式18-观察者模式

观察者模式是一个应用非常广的模式之一，定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。当一个对象发生了变化，关注它的对象就会得到通知；这种交互也称为发布-订阅(publish-subscribe)。目标是通知的发布者，它发出通知时并不需要知道谁是它的观察者。下面是观察者的类图接下来看一个示例，代码如下：class observer{public: observer() = default; virtual ~observer(){}

2021-06-27 23:07:36 89

原创深度探索c++对象模型-03-VPTR在对象空间中的位置

看如下代码：class Test{public: char a; virtual void go() { }};void main(){ Test t; t.a = 'c'; cout << "sizeof(t):" << sizeof(t) << endl; char *ptra = reinterpret_cast<char *>(&t.a); char *ptrobj = reinterpret_cast&lt

2021-06-24 22:33:41 189 2

原创深度探索c++对象模型-02-this指针调整

先看如下代码class A{public: int a; A() { printf("A::A()的this指针:%p!\n", this); } void funA() { printf("A::funA()的this指针:%p!\n", this); } };class B{public: int b; B() { printf("B::B()的this指针:%p!\n", this); } void funB() { printf(

2021-06-23 00:16:20 207 3

原创如何使用def创建一个dll

1.选择MFC DLL2.点击完成接下来看看怎么实现写dll.第一步先创建一本接口类，calcbase.h#pragma oncetypedef void * CallBackPara;//回调函数接收的参数typedef void(*pMessageCallback)(char* pMsg, CallBackPara param);//回调函数原型class calcbase{public: calcbase(){}; virtual ~calcbase(){}; //将

2021-06-22 23:02:40 371 1

原创不使用向导自己搭建一个MFC程序

阅读此文，希望你对windows编程了解一些看下图，我就创建了两个文件：先看结果：接下来看看怎么实现：先看mfc.h：#include <afxwin.h>//应用程序类 class MyApp :public CWinApp{public: virtual BOOL InitInstance() override;};//框架类class MyFrame :public CFrameWnd{ //声明消息映射 DECLARE_MESSAGE_MAP()

2021-06-22 22:14:15 165

原创深度探索c++对象模型-01-空类的大小、成员函数、成员变量的大小

一、空类大小class A{};void main(){ A a; cout <<"sizeof(a):"<< sizeof(a) << endl; system("pause");}结果：从结果可以看出，空类的大小是1，这是为了空类可以被实例化，并且每个实例在内存中都有独一无二的地址，因此，编译器会给空类隐含加上一个字节，这样空类实例化之后就会拥有独一无二的内存地址。如果没有这一个字节的占位，那么空类就无所谓实例化了，因为实例化的过程就

2021-06-20 13:20:20 323

原创 c++多线程之recursive_mutex

先看一个案例：std::mutex g_mutex;void fun2(){ std::lock_guard<std::mutex> lc(g_mutex); cout << "我是fun2\n"; }void fun1(){ std::lock_guard<std::mutex> lc(g_mutex); cout << "我是fun1\n"; fun2();}void main(){ fun1(); syste

2021-06-18 22:36:37 354

原创 c++多线程之利用RALL技术写一个安全的临界区

CRITICAL_SECTION g_cs;class CMySafeLock{public: CMySafeLock(CRITICAL_SECTION *p) { m_pCS = p; cout << "----------------lock------------------\n"; EnterCriticalSection(m_pCS); } ~CMySafeLock() { LeaveCriticalSection(m_pCS); cout &lt

2021-06-18 21:58:12 432

原创 c++多线程之atomic

原子操作，一般都是指“不可分割的操作”，也就是说这种操作状态要么是完成的，要么是没完成的，不可能出现半完成状态；std::atomic代表原子操作，是一个类模板，其实这个东西用来封装某个类型的值的。注意和互斥量的区分，互斥量的加锁一般都是针对一个代码段（几行代码），而原子操作针对的一般都是一个变量，而不是一个代码段，是无锁的。下面看一个简单的例子，就是共同写一个数字，然后最后访问。int ncount = 0;std::mutex mutex1;void testx(){ clock_t .

2021-06-14 22:42:39 527

原创 c++多线程之shared_future

shared_future也是一个类模板，get的时候是克隆（复制）出一个数据，而不是直接取出，所以能多次get()，下面是例子：void testPromise(std::promise<int> &mypromise, int x){ cout << "我是第一个线程,正在处理数据\n"; int nresult = 0; nresult = x + 10; nresult += 100; nresult -= 1; std::this_thread::s

2021-06-14 21:00:21 1151

原创 c++多线程之future的wait_for

下面是主函数：

2021-06-14 16:35:01 1117

原创 c++多线程之promise

std::promise是一个类模板，能够在某个线程中给它赋值，然后我们可以再其它线程中把这个值取出来。下面是调用下面是完整的代码：void testPromise(std::promise<int> &mypromise, int x){ cout << "x:" << x << endl; int nresult = 0; nresult = x + 10; nresult += 100; nresult -= 1; std

2021-06-14 15:55:43 2581 1

原创 c++多线程之packaged_task

packaged_task是个类模板，用于打包任务，把任务包装起来。它的模板参数是各种调用对象，通过std::packaged_task来把各种可调用对象包装起来，方便将来作为线程入口函数来调用。下面是一个例子：int test(int x){ cout << "Child threadID:" << std::this_thread::get_id() << endl; cout << "X:" << x << endl;

2021-06-14 14:56:03 310

原创 c++多线程之async(),future

std::async()、std::future创建后台任务并返回值。希望线程返回一个结果。std::async()是个函数模板，用来启动一个异步任务，启动这个异步任务之后，它返回一个std::future对象，这个std::future包含线程入口函数返回的结果（线程返回的结果），我们可以调用future的成员函数get()来获取。int test(int x){ cout << "Child threadID:" << std::this_thread::get_id()

2021-06-13 23:50:51 528 1

原创 c++多线程之单例模式为什么懒汉式不安全，以及解决办法

下面先说说为什么它不安全：class JackTang{private: JackTang() { } //不能在析构函数中析构这个静态对象，这是一种错误的做法，虽然会调用，但是一个死递归，正确做法 //是创建一个嵌套析构类(下面的B)。 /*~JackTang() { if (pInstance) { cout << "hello "; delete pInstance;//递归调用 pInstance = NULL; cout

2021-06-13 15:37:35 591 1

原创 c++多线程之release

std::mutex m_utex1;int ncount = 0;void mythread1(){ for (int i = 0; i < 100;i++) { unique_lock<std::mutex> lc(m_utex1); cout << ncount << " "; }}void mythread2(){ for (int i = 0; i < 100; i++) { unique_lock&l.

2021-06-13 00:24:27 431

原创 c++11多线程之使用std::try_to_lock摸鱼

代码如下：结果：从结果看出，当拿不到锁的时候，没有在那里傻傻的等待，而是偷偷摸鱼了19次，这样计算机资源就被我们充分利用起来了。下面说说std::try_to_lock的作用：使用该关键字后，会尝试去锁定m_utex,但如果没有锁定成功，也会立即返回，并不会阻塞在那里。...

2021-06-11 16:41:23 1190 2

原创 c++多线程之死锁

什么是死锁？死锁 (deallocks)：是指两个或两个以上的进程（线程）在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。此时称系统处于死锁状态或系统产生了死锁，这些永远在互相等待的进程（线程）称为死锁进程（线程）。我们举个例子来描述，如果此时有一个线程A，按照先锁a，再锁b,而在此同时又有另外一个线程B，按照先锁b再锁a的顺序获得锁。如下图所示：就如图这种情况下，线程A在等待锁b，可是锁b被锁住了，所以此时不能往下进行，需要等待锁b释放，而线程B先是锁住了

2021-06-08 21:26:48 3851 1

原创 c++11之多线程创建方式

函数无参使用一个无参函数创建线程，thread 的构造接受一个参数，即函数名。//编写一个函数作为线程的执行路径void myprint() { cout << "我的线程开始运行" << endl; cout << "我的线程开始运行" << endl; cout << "我的线程开始运行" << endl; cout << "我的线程开始运行" << endl; cout << "

2021-06-06 23:28:18 347

原创 c++多线程传参之意料之外的事

先看代码：class JackTang{public: int number; mutable int x{ 101 }; JackTang(int a) :number(a) { } JackTang(const JackTang &obj) { number = obj.number; ; } ~JackTang() { }};void test1(JackTang &obj){ obj.x = 1111;}void t

2021-06-05 19:12:26 121

原创 list的迭代器可改变真实元素

结果:

2021-06-05 10:55:33 105

原创 c++多线程之detach的坑

坑的来源就是，主线程退出了，子线程还没有结束。然后传递的参数要不失效，要不隐式转化失败等。class JackTang{public: int number; JackTang(int a) :number(a) { cout << "这是构造函数\n"; } JackTang(const JackTang &obj) { number = obj.number; cout << "这是Copy构造函数\n"; } ~JackTang(

2021-06-04 23:38:35 569 1

原创 c++基础之引用

1. 什么是引用引用不是创建一个新的变量，而是给一个已经定义的变量重新起一个别名，对引用的操作与对变量直接操作完全一样。引用的声明方法：类型标识符 &引用名=目标变量名；例如：int main(){ int a = 10; int& b = a; //b就是a的引用 cout << "The address of a is " << &a << endl; cout &lt

2021-06-03 22:52:59 121 3