C++ 实现QT信号槽

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140162260

https://github.com/libsigcplusplus/libsigcplusplus

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
#include <iostream>

/*
////在sigslot.h的420,将：
//typedef sender_set::const_iterator const_iterator;
////改为：
//typedef typename sender_set::const_iterator const_iterator;

#include <sigslot.h>
using namespace sigslot; //必须加上sigslot的命名空间
//在用vs调试时还需要将sigslot.h中很多的自定义模板结构类型前加typename
const int TTRUE = 1;
const int TFALSE = 0;
class Switch
{
public:
	signal0<> Clicked;
	//这里的信号是不带参数的，signaln表示带几个参数
};
class Light : public has_slots<>
{
public:
	Light(bool state) { b_state = state; Displaystate(); }
	void ToggleState() { b_state = !b_state; Displaystate(); } //作为消息的响应
	void TurnOn() { b_state = TTRUE; Displaystate(); }
	void TurnOff() { b_state = TFALSE; Displaystate(); }
	void Displaystate() { std::cout << "The state is " << b_state << std::endl; }
private:
	bool b_state;
};
void main()
{
	Switch sw1, sw2, all_on, all_off;
	Light lp1(TTRUE), lp2(TFALSE);
	sw1.Clicked.connect(&lp1, &Light::ToggleState); //绑定
	sw2.Clicked.connect(&lp2, &Light::ToggleState);
	all_on.Clicked.connect(&lp1, &Light::TurnOn);
	all_on.Clicked.connect(&lp2, &Light::TurnOn);
	all_off.Clicked.connect(&lp1, &Light::TurnOff);
	all_off.Clicked.connect(&lp2, &Light::TurnOff);

	sw1.Clicked();
	sw2.Clicked();
	all_on.Clicked();
	all_off.Clicked();

	sw1.Clicked.disconnect(&lp1);
	sw2.Clicked.disconnect(&lp2);
	all_on.Clicked.disconnect(&lp1);
	all_on.Clicked.disconnect(&lp2);
	all_off.Clicked.disconnect(&lp1);
	all_off.Clicked.disconnect(&lp2);
}
*/

#include <sigc++/sigc++.h>
class AlienDetector
{
public:

	void run() { signal_detected.emit("test"); }

	sigc::signal<void(std::string)> signal_detected;	// changed
};

void warn_people(std::string where)
{
	std::cout << "There are aliens in " << where << "!" << std::endl;
}

int main_callback()
{
	AlienDetector mydetector;
	auto target = mydetector.signal_detected.connect(sigc::ptr_fun(warn_people));  // return sigc::connection


	mydetector.run();

	target.disconnect();
	return 0;
}

创作不易，小小的支持一下吧！

展开全文 >>

C++字体库开发二

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140161915

Font:
字体大小，方向，变换
FontContext:
多语言，更新，基础字体，表情
FontDescription:
字重，子样式，名称，底色
FontDir:
字体目标
FontFace:
Regular,Bold特殊字重
FontFamily:
字体簇名
FontMap:
字体库，加载和查询，版本管理，字体缓存
FontSet:
字体列表
FontParse:
字体解析，安装和删除字体 

FontCoverage:

字体回退

C++字体库开发-CSDN博客

创作不易，小小的支持一下吧！

展开全文 >>

C++ ariac2 Windows库编译

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140138459

cd “F:\\aria2”
gmp-6.1.2.tar.lz
expat-2.2.0.tar.bz2
sqlite-autoconf-3160200.tar.gz
zlib-1.2.11.tar.gz
c-ares-1.12.0.tar.gz
libssh2-1.8.0.tar.gz

--enable-libaria2
--enable-static

libgnutls-dev（对于HTTPS，BitTorrent，校验和支持是必需的）
nettle-dev（对于BitTorrent，校验和支持）
libgmp-dev（对于BitTorrent是必需的）
libssh2-1-dev（SFTP支持需要）
libc-ares-dev（需要异步DNS支持）
libxml2-dev（Metalink支持需要）
zlib1g-dev（对于gzip必需，在HTTP中支持解压缩）
libsqlite3-dev（适用于Firefox3 / Chromium cookie支持）
pkg-config（用于检测已安装的库）

apt-cyg安装工具设置   https://blog.csdn.net/jinguangliu/article/details/79657456    
./autogen.sh
autoscan
aclocal
autoheader
automake –add-missing
autoreconf  -ivf
autoconf

./configure
./configure ARIA2_STATIC = yes
export CXXFLAGS=”-g -O2 -mwindows”     //无控制台启动aria2.exe
make
HOST = x86_64-w64-mingw32 ./mingw-config
i686-w64-mingw32

#ifdef BUILD_DLL
    #define DLL_EXPORT __declspec(dllexport)
#else
    #define DLL_EXPORT __declspec(dllimport)
#endif

ARIA2_DLL_API int64_t             extern “C” int64_t ARIA2_DLL_API
ARIA2_DLL_API int             extern “C” int ARIA2_DLL_API
ARIA2_DLL_API void             extern “C” void ARIA2_DLL_API
ARIA2_DLL_API bool             extern “C” bool ARIA2_DLL_API
ARIA2_DLL_API A2Gid             extern “C” A2Gid ARIA2_DLL_API
ARIA2_DLL_API DownloadHandle*             extern “C” DownloadHandle* ARIA2_DLL_API
ARIA2_DLL_API DownloadStatus             extern “C” DownloadStatus ARIA2_DLL_API
ARIA2_DLL_API Session*      extern “C” Session* ARIA2_DLL_API
ARIA2_DLL_API time_t      extern “C” time_t ARIA2_DLL_API
ARIA2_DLL_API BtFileMode      extern “C” BtFileMode ARIA2_DLL_API
ARIA2_DLL_API size_t      extern “C” size_t ARIA2_DLL_API

extern “C” int ARIA2_DLL_API64_t           extern “C” int64_t ARIA2_DLL_API

//vs开发人员工具命令行
pexports libaria2-0.dll>libaria2-0.def
lib /def:libaria2-0.def /machine:i386 /out:libaria2-0.lib

我这里是直接修改Qt编译后的配置,找到
QTDIR/mkspec/win32-g++ /qmake.conf,QMAKE_LFLAGS = -static-libgcc -static-libstdc++改成这样,
这段代码是去掉了对上面所说两个动态链接库的动态调用依赖.

Windows下特殊处理

#define CXX11_OVERRIDE override
#define PACKAGE_VERSION 0
typedef size_t ssize_t;
#include “pch.h”
#define NOMINMAX  

参考

GitHub - jashking/aria2: aria2 is a lightweight multi-protocol & multi-source, cross platform download utility operated in command-line. It supports HTTP/HTTPS, FTP, SFTP, BitTorrent and Metalink.

http://wangjie.rocks/2017/02/12/build-aria2/

https://github.com/aria2/aria2.git

https://github.com/geetam/qaria/tree/master/src

https://github.com/manox14/qtaria

dll.a和lib 引用MinGW生成的dll.a后出现的问题_生成了dll.a-CSDN博客

https://github.com/imazes/aria2_ctl

https://github.com/cool2528/aria2cengine.git

https://github.com/jashking/aria2/blob/master/src/includes/aria2/aria2.h

http://wangjie.rocks/2017/02/12/build-aria2/

创作不易，小小的支持一下吧！

展开全文 >>

C++字体库开发

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140137814

建议根据字体需求，多个组合使用。高度定制可基于freeType+harfbuzz基础库完成。

GitHub - GNOME/pango: Read-only mirror of https://gitlab.gnome.org/GNOME/pango

GitHub - googlefonts/fontview: Demo app that displays fonts with a free/libre/open-source text rendering stack: FreeType, HarfBuzz and Raqm

盐小咸/sfntly

GitHub - googlefonts/sfntly: A Library for Using, Editing, and Creating SFNT-based Fonts

https://github.com/googlei18n/fontview

mirrors_phil-r/varfonts-ofl

GitHub - googlefonts/fontview: Demo app that displays fonts with a free/libre/open-source text rendering stack: FreeType, HarfBuzz and Raqm

fontconfig 

创作不易，小小的支持一下吧！

展开全文 >>

C++仿SKData实现C原生指针管理

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140109232

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

template<typename T, typename SizeT = size_t>
class HBData {
public:
    HBData() : data(nullptr), size(0), isDeepCopy(false) {}
    HBData(const T* other_data, size_t other_size, bool release) : data(other_data), size(other_size), isDeepCopy(release) {}
    HBData(const HBData& other) {
        if(isDeepCopy && data)
            delete[] data;
        data = new T[other.size];
        auto len = sizeof(T) * other.size;
        memcpy_s(data, len, other.data, len);
        size = other.size;
        isDeepCopy = true;
    }
    ~HBData() {
        if(isDeepCopy && data)
            delete[] data;
    }
public:
    const T* data;
    SizeT size;
    bool isDeepCopy;
};
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

template <typename T, typename SizeT = size_t>
class HBData
{
public:
    HBData() : data(nullptr), size(0) {}
    HBData(const T *ptr, SizeT len) : data(ptr), size(len), ref(std::make_shared<int>(1)) {}
    HBData(const HBData &other) { *this = other; }
    ~HBData()
    {
        if (!ref)
            return;
        if (1 != ref.use_count())
            return;
        delete[] data;
    }
    HBData deepCopy() const
    {
        auto   newData = new T[size];
        HBData hbData(newData, size);
        auto   len = sizeof(T) * size;
        memcpy_s(newData, len, data, len);
        return hbData;
    }

public:
    const T             *data;
    SizeT                size;
    std::shared_ptr<int> ref;
};

https://chromium.googlesource.com/external/skia/include/+/f2e084053cd1dbd21fa3cece80d70045b2b0b83b/core/SkData.h

C++自定义智能指针-CSDN博客

创作不易，小小的支持一下吧！

展开全文 >>

C++旋转点坐标计算

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140087219

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
     /// 获取A点绕B点旋转P度后的新坐标
       /// </summary>
       /// <param name="Angle">角度</param>
       /// <param name="CirPoint">圆心坐标</param>
       /// <param name="MovePoint">移动点的坐标</param>
       /// <param name="FlagInt">顺时针：1(默认)  逆时针:-1</param>
       /// <returns></returns>       

public static Point GetNewPoint(double Angle, Point CirPoint, Point MovePoint, int FlagInt = 1)
       {
           //将角度转换成弧度
           double Rage2 = Convert.ToDouble(Angle) / 180 * Math.PI;
           //计算新坐标X
           int newx = (int)((MovePoint.X - CirPoint.X) * Math.Cos(Rage2 * FlagInt) - (MovePoint.Y - CirPoint.Y) * Math.Sin(Rage2 * FlagInt));
           //计算新坐标Y
           int newy = (int)((MovePoint.Y - CirPoint.Y) * Math.Cos(Rage2 * FlagInt) + (MovePoint.X - CirPoint.X) * Math.Sin(Rage2 * FlagInt));
           //计算新坐标
           Point newpoint = new Point(CirPoint.X + newx, CirPoint.Y + newy);
           //返回新坐标
           return newpoint;
       }

创作不易，小小的支持一下吧！

展开全文 >>

C++ Windows原生内存泄漏分析

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140087110

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
#include "stdafx.h"
#include <string>
#include <stdlib.h>  
#include <crtdbg.h>
#include <iostream>
using namespace std;

#ifdef _DEBUG  
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)  
#endif

void EnableMemLeakCheck()
{
    int tmpFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
    tmpFlag |= _CRTDBG_LEAK_CHECK_DF;
    _CrtSetDbgFlag(tmpFlag);
}

int _tmain(int argc, _TCHAR* argv[])
{
    EnableMemLeakCheck();
    //_CrtSetBreakAlloc(207);
        char* p = new char[100];
        //delete p;
       getchar();
      //_CrtDumpMemoryLeaks();//这个代码好像会输出额外多余的内存分配信息
    return 0;
}

创作不易，小小的支持一下吧！

展开全文 >>

C++自定义智能指针

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140072320

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
template <class T>
class counted_ptr;

// 智能指针引用计数类
template <class T>
class Ref_Ptr
{
	friend class counted_ptr<T>;
private:
	T* m_pTtr; // 实际的指针
	size_t counted_ptr; // 引用计数
	Ref_Ptr(T* p);
	virtual ~Ref_Ptr();
};

template <class T>
Ref_Ptr<T>::Ref_Ptr(T* p)
{
	m_pTtr = p;
	counted_ptr = 1;
	cout<<"Ref_Ptr() 构造函数调用!"<<endl;
}

template <class T>
Ref_Ptr<T>::~Ref_Ptr()
{
	if (m_pTtr)
	{
		cout<<"~Ref_Ptr() 析构函数函数调用"<<endl;
		delete m_pTtr;
		counted_ptr = 0;
	}
	m_pTtr = NULL;
}

// 智能指针对象
template <class T>
class counted_ptr
{
private:
	Ref_Ptr<T>* m_pRef; // 引用计数
public:
	counted_ptr();
	counted_ptr(T* p);
	~counted_ptr();
	// 重载运算=,将左对象引用计数-1,并判断是否delete;将右对象+1;
	counted_ptr<T> & operator = (counted_ptr& other);
	// 重载指针操作*,->
	T& operator *();
	T* operator ->();
	// 拷贝构造函数,引用计数+1
	counted_ptr(counted_ptr<T>& other);
};
template <class T>
counted_ptr<T>::counted_ptr()
{
	m_pRef = NULL;
}

template<class T>
counted_ptr<T>::counted_ptr(T* p)
{
	m_pRef = new Ref_Ptr<T>(p);
	cout<<"counted_ptr(T* p) 构造函数调用"<<endl;
}

template <class T>
counted_ptr<T>::counted_ptr(counted_ptr<T>& other)
{
	this->m_pRef = other.m_pRef;
	++(m_pRef->counted_ptr);
	cout<<"counted_ptr(& other) 拷贝构造函数被调用,当前引用计数"<< this->m_pRef->counted_ptr<<endl;
}

template <class T>
counted_ptr<T>& counted_ptr<T>::operator=(counted_ptr& other)
{
	// 将右操作对象引用计数+1
	++(other.m_pRef->counted_ptr);

	// 由于左操作对象指向了新对象,需要将操作数-1;
	// 同时也防止了自赋值的方式.
	// 首先要判断这个对象是否已经指向了其他对象,这个很重要!防止左指针对象为null的情况.
	if (this->m_pRef)
	{
		if (--(this->m_pRef->counted_ptr) == 0)
		{
			delete this->m_pRef;
		}
	}

	this->m_pRef = other.m_pRef;
	cout<<"operator = 被调用,当前引用计数"<< this->m_pRef->counted_ptr<<endl;
	return *this;
}

template <class T>
T& counted_ptr<T>::operator *()
{
	return *(m_pRef->m_pTtr);
}

template <class T>
T* counted_ptr<T>::operator->()
{
	return (m_pRef->m_pTtr);
}

template <class T>
counted_ptr<T>::~counted_ptr()
{cout<<"~counted_ptr() 析构函数被调用"<<endl;
	if ((--m_pRef->counted_ptr) == 0)
	{
		cout<<"删除"<<endl;
		delete m_pRef;
		m_pRef = NULL;
	}
	if (m_pRef)
	{
		cout<<"当前引用计数:"<< m_pRef->counted_ptr<<endl;
	}
}


int  main()
{
	counted_ptr<int>* pPtr = NULL;

	{
		counted_ptr<int> g_ptr;
		{
			// 声明一个ptr1智能指针,并测试*运算符
			counted_ptr<int> ptr1(new int(4));
			counted_ptr<int> ptr2;
			cout<< "*ptr1="<< *ptr1<<endl;
			// 将生存期小的ptr1赋值给生存期更大的g_ptr;
			ptr2 = ptr1;
			system("pause");
			g_ptr = ptr1;
			system("pause");
		}
		// new int(4)并没有销毁,因为引用计数还有1个
		cout<<" *g_ptr="<<*g_ptr << endl;
		system("pause");
	}
	system("pause");
	getchar();
	return 0;
}

参考 

std::shared_ptr - cppreference.com

创作不易，小小的支持一下吧！

展开全文 >>

UML建模笔记

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140065026

5个视图
  1. 设计。类，接口，对象如何协作。
  2. 实现。组件，运行程序，文档关系。
  3. 用例。用户功能期望。
  4. 进程。并发与同步相关进程，线程。
  5. 部署。部署到计算机。
建模目的
  1. 和客户共创
  2. 追踪需求变更
  3. 协同开发
  4. 进度控制
  5. 持续迭代
  6. 测试
  7. 生成代码
开发周期

用户需求，领域分析，概要设计，详细设计，编码测试，部署

开发模式

需求不明确，工作量小。极限编程，即兴开发，敏捷

需求不明确，工作量大。瀑布，迭代

需求明确，工作量大。瀑布，迭代

需求明确，工作量小。敏捷，迭代

用户动态参与，每阶段需要输出动态系统。敏捷，迭代

创作不易，小小的支持一下吧！

展开全文 >>

C++轻量级枚举反射

本文作者原创，首发在本博客；CSDN 上的同名文章已标注为转载并回链到本页：https://blog.csdn.net/qq_30220519/article/details/140034053

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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
#pragma once
#include <iostream>
#include <string>

namespace scienum {

    namespace details {

        template <class T, T N>
        const char* get_enum_name_static() {
#if defined(_MSC_VER)
            return __FUNCSIG__;
#else
            return __PRETTY_FUNCTION__;
#endif
        }

        template <bool Cond>
        struct my_enable_if {
        };

        template <>
        struct my_enable_if<true> {
            typedef void type;
        };

        template <int Beg, int End, class F>
        typename my_enable_if<Beg == End>::type static_for(F const& func) {
        }

        template <int Beg, int End, class F>
        typename my_enable_if<Beg != End>::type static_for(F const& func) {
            func.template call<Beg>();
            static_for<Beg + 1, End>(func);
        }

        template <class T>
        struct get_enum_name_functor {
            int n;
            std::string& s;

            get_enum_name_functor(int n, std::string& s) : n(n), s(s) {}

            template <int I>
            void call() const {
                if (n == I) s = details::get_enum_name_static<T, (T)I>();
            }
        };

    }

    template <class T, T Beg, T End>
    std::string get_enum_name(T n) {
        std::string s;
        details::static_for<Beg, End + 1>(details::get_enum_name_functor<T>(n, s));
        if (s.empty())
            return "";
#if defined(_MSC_VER)
        size_t pos = s.find(',');
        pos += 1;
        size_t pos2 = s.find('>', pos);
#else
        size_t pos = s.find("N = ");
        pos += 4;
        size_t pos2 = s.find_first_of(";]", pos);
#endif
        s = s.substr(pos, pos2 - pos);
        size_t pos3 = s.rfind("::");
        if (pos3 != s.npos)
            s = s.substr(pos3 + 2);
        return s;
    }

    template <class T>
    std::string get_enum_name(T n) {
        return get_enum_name<T, (T)0, (T)256>(n);
    }

    template <class T, T Beg, T End>
    T enum_from_name(std::string const& s) {
        for (int i = (int)Beg; i < (int)End; i++) {
            if (s == get_enum_name((T)i)) {
                return (T)i;
            }
        }
        throw;
    }

    template <class T>
    T enum_from_name(std::string const& s) {
        return enum_from_name<T, (T)0, (T)256>(s);
    }

}

enum Color {
    RED, GREEN, BLUE, YELLOW,
};

int test() {
    std::cout << scienum::get_enum_name(YELLOW) << std::endl;
    std::cout << scienum::enum_from_name<Color>("YELLOW") << std::endl;
    return 0;
}

输出

YELLOW
3

创作不易，小小的支持一下吧！

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家