<?xml version="1.0" encoding="utf-8" ?><rss version="2.0"><channel><title><![CDATA[ZZHinclude的博客]]></title><description><![CDATA[]]></description><link>https://blog.youkuaiyun.com/ZZHinclude</link><language>zh-cn</language><generator>https://blog.youkuaiyun.com/</generator><copyright><![CDATA[Copyright &copy; ZZHinclude]]></copyright><item><title><![CDATA[lua和C的交互]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/146589189</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/146589189</guid><author>ZZHinclude</author><pubDate>Wed, 02 Apr 2025 16:39:54 +0800</pubDate><description><![CDATA[一个简单的例子struct Posint x;int y;p->x = v;return 0;p->y = v;return 0;return 1;return 1;p->y = y;p->x = x;return 1;int main()//用于创建一个新的lua虚拟机//打开标准库// 将 table 绑定到全局变量 "g_Cfuns"= LUA_OK)//关闭lua虚拟机return 0;]]></description><category></category></item><item><title><![CDATA[lua面向对象]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/146534708</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/146534708</guid><author>ZZHinclude</author><pubDate>Wed, 26 Mar 2025 17:44:53 +0800</pubDate><description><![CDATA[(可以看看我上一篇lua的元表和元方法)]]></description><category></category></item><item><title><![CDATA[元表和元方法]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/146532139</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/146532139</guid><author>ZZHinclude</author><pubDate>Wed, 26 Mar 2025 16:26:16 +0800</pubDate><description><![CDATA[1. 元表其实也是lua中的一种表，即table，但是它可以自定义某个表的行为，比如运算符重载、默认值查找、访问控制等 2. 当一个表 t 进行某些操作（如 t1 + t2、访问 t . key）时，Lua 会检查 t 是否有元表，并尝试调用元表中的元方法。]]></description><category></category></item><item><title><![CDATA[find和find_if]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/126785910</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/126785910</guid><author>ZZHinclude</author><pubDate>Fri, 09 Sep 2022 16:50:19 +0800</pubDate><description><![CDATA[STL]]></description><category></category></item><item><title><![CDATA[初试完成端口]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/124583957</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/124583957</guid><author>ZZHinclude</author><pubDate>Thu, 05 May 2022 10:40:47 +0800</pubDate><description><![CDATA[1.完成端口写的好的博客地址
博客1
博客2
2.简易服务器实现代码
#include &lt;iostream&gt;
#include &lt;winsock2.h&gt;
#include &lt;ws2def.h&gt;
using namespace std;

#define MAX_SIZE 1024
#define LISTEN_SOCK_PORT 5060

#pragma comment( lib, "ws2_32.lib" ) 

//代表参数完成键 CompletionPort
ty]]></description><category></category></item><item><title><![CDATA[初探重叠IO]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/124581688</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/124581688</guid><author>ZZHinclude</author><pubDate>Thu, 05 May 2022 10:35:13 +0800</pubDate><description><![CDATA[个人学习总结笔记 对于这一块也不算很通透，如果大家发现错误，一定要及时告诉我
1.基于重叠IO的网络异步模型
有两个写法，一个是基于完成例程的，一个是基于事件的，用完成例程的复杂而且效率不如完成端口，所以在此只介绍基于事件的。
2.windows下的事件
就是你创建一个事件对象，一般来说初始都是将该事件对象设置为无信号的，然后在该事件对象上绑定上你感兴趣的一个操作，然后调用事件等待函数等待该事件的发生，等待过程中线程是被挂起的(也就是说阻塞在了等待处)，不耗费CPU的资源，当感兴趣的操作发生的时候，会将事件]]></description><category></category></item><item><title><![CDATA[快速初始化成员变量和sizeof]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122663411</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122663411</guid><author>ZZHinclude</author><pubDate>Fri, 28 Jan 2022 10:30:16 +0800</pubDate><description><![CDATA[1.快速初始化成员变量
①在C++98的标准
可以在类中使用 “=初始值” 的方式来对类中的成员进行初始化，但是是十分严格的，，如果静态成员不满足常量性，且成员不是整型或枚举类型，是无法初始化的
非静态成员的初始化，在构造函数中进行

②在c++11当中，可以使用= {} 来对非静态成员变量来进行初始化
class Test
{
     int a = 10;
     double b{ 1.3 };

     vector&lt;int&gt; c{ 1,2,3,4,5 };

     
};

]]></description><category></category></item><item><title><![CDATA[noexcept修饰符和noexcept操作符]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122662435</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122662435</guid><author>ZZHinclude</author><pubDate>Mon, 24 Jan 2022 10:51:50 +0800</pubDate><description><![CDATA[1. 弃用throw
我们可能见过的异常处理 长这个样子
void except_fun() throw(int, double) {  }

但是由于该特性很少被使用到，所以被弃用了
表示函数不会抛出异常的throw() 也已经被新的关键字noexcept关键字代替
2.noexcept
表示其修饰的函数 不会抛出异常，在西皮皮11中，如果noexcept修饰的函数抛出了异常，那么编译器会调用std::terminate()直接终止运行了，
从语法上面讲 有两种形式
①
void fun() noexce]]></description><category></category></item><item><title><![CDATA[Chapter 4 How to Benefit from Move Semantics]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122596181</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122596181</guid><author>ZZHinclude</author><pubDate>Fri, 21 Jan 2022 10:45:40 +0800</pubDate><description><![CDATA[1. Avoid Objects with Names
①如果编译器检测到一个值 来自于一个生命周期即将结束的对象，那么他便会自动的去选择移动语意
传递临时对象
返回一个局部变量 return local object by value
②除此之外我们还可以显示标记一个对象 std::move()
尽量避免给对象命名
MyType x{42, "hello"};
foo(x); // x not used afterwards

这个x对象，以后就没有使用过了，那么我们就可以用另一种方式代替
foo(MyT]]></description><category></category></item><item><title><![CDATA[Chapter3 Move Semantics in Classes]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122554613</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122554613</guid><author>ZZHinclude</author><pubDate>Thu, 20 Jan 2022 10:14:31 +0800</pubDate><description><![CDATA[1. Move Semantics in Ordinary Classes
①C++11之后，编译器会为简单的类生成 移动构造函数 和 移动赋值运算符
(就像生成的默认构造函数和默认赋值运算符)
②什么时候会使用移动构造

当返回一个局部变量(return local obj by value)
按值传递一个无名对象
传递一个临时对象(例如 函数的返回值)
被std::move 标记的对象

③测试代码
一个简单的类 只有构造函数和一个重载的运算符
class Test
{
public:
     Tes]]></description><category></category></item><item><title><![CDATA[2.5 Passing by Value 2.6 Summary]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122534328</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122534328</guid><author>ZZHinclude</author><pubDate>Mon, 17 Jan 2022 11:19:52 +0800</pubDate><description><![CDATA[1.Passing by Value
函数形参的声明 是pass by value
void foo(std::string str); // takes the object by value

std::string s{"hello"};
...
foo(s); // calls foo(), str becomes a copy of s

foo(std::move(s)); // calls foo(), s is moved to str

foo(returnStringByValue())]]></description><category></category></item><item><title><![CDATA[2.4 Overloading by Different References]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122532949</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122532949</guid><author>ZZHinclude</author><pubDate>Mon, 17 Jan 2022 10:07:18 +0800</pubDate><description><![CDATA[1.Overloading by Different References
在我们了解完右值引用之后，我们有三种形参可以pass by reference
void foo(const std::string&amp; arg)

void foo(std::string&amp; arg)

void foo(std::string&amp;&amp; arg)

2. void foo(const std::string&amp; arg)
①形参表示 你对传过来的实参 只具有读的权限
②将实参作为 c]]></description><category></category></item><item><title><![CDATA[2.3 Moved-from Objects]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122489583</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122489583</guid><author>ZZHinclude</author><pubDate>Fri, 14 Jan 2022 11:22:52 +0800</pubDate><description><![CDATA[1.Moved-from Objects
在一个对象被std::move()以后，仍然是有效的一个对象，在其生命周期结束的时候会调用其析构函数。
只不过该对象的值变得不确定了。
2.Valid but Unspecified State
C++的标准库保证move以后，仍然是有效的对象，但却不能保证他的value
std::string s;
...
coll.push_back(std::move(s));

foo(std::move(s)); // keeps s in a valid but unc]]></description><category></category></item><item><title><![CDATA[2.2 std::move()]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122487493</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122487493</guid><author>ZZHinclude</author><pubDate>Fri, 14 Jan 2022 09:57:42 +0800</pubDate><description><![CDATA[1. std::move()
①我们都知道 对象都有生命周期，当生命周期结束的时候，对象会被销毁释放
②我们可以在一个对象生命周期没有结束的时候，我们可以对一个对象使用move标记，来表示 我不在需要这个对象了，仅使用std::move()并没有真的被move，只是作为一个标记
void foo(const std::string&amp; lr); 
// binds to the passed object without modifying it

void foo(std::string&amp;&]]></description><category></category></item><item><title><![CDATA[2.1 Rvalue References]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122487074</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122487074</guid><author>ZZHinclude</author><pubDate>Fri, 14 Jan 2022 09:31:17 +0800</pubDate><description><![CDATA[1. Rvalue References
std::string returnStringByValue(); // forward declaration
...
std::string s{"hello"};
...
std::string&amp;&amp; r1{std::move(s)}; // OK

std::string&amp;&amp; r2{returnStringByValue()}; 
// OK, extends lifetime of return value

std::st]]></description><category></category></item><item><title><![CDATA[1.5 Summary]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122482312</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122482312</guid><author>ZZHinclude</author><pubDate>Thu, 13 Jan 2022 20:51:55 +0800</pubDate><description><![CDATA[1.总结
①移动语意 可以使我们呢优化数据的拷贝，可以隐式的使用(return by value
或者是 右值传参) 或者直接显式 std::move()
②std::move()仅仅是代表一个对象是可移动的，该对象仍然存在，但是他的值不确定了，具体看编译器的实现
③通过使用 non-const &amp;&amp; 作为形参，调用者可以将它不在需要的对象传递进来，此函数将在内部对实参进行任何需要的修改
④当没有实现移动语意的时候，你仍然可以使用std::move,因为当编译器找不到移动语意的时候，他便会使]]></description><category></category></item><item><title><![CDATA[1.4Move Semantics for const Objects]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122482002</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122482002</guid><author>ZZHinclude</author><pubDate>Thu, 13 Jan 2022 20:43:49 +0800</pubDate><description><![CDATA[1.Move Semantics for const Objects
被const修饰的对象 不能被move
move就是要修改传入的值，去"偷"
2.类的定义
class MyString
{
public:
     MyString(int Len = 0, const char* Str = nullptr) : nLen{ Len } 
     {
          cout &lt;&lt; "默认构造函数" &lt;&lt; endl;
          pStr = new char[]]></description><category></category></item><item><title><![CDATA[1.2 Implementing Move Semantics]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122480827</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122480827</guid><author>ZZHinclude</author><pubDate>Thu, 13 Jan 2022 20:25:25 +0800</pubDate><description><![CDATA[1. Implementing Move Semantics
①C++11 以前的push_back()的实现 只有一种
template&lt;typename T&gt;
class vector 
{
public:
...
// insert a copy of elem:
void push_back (const T&amp; elem);
...
};

也就是说，你只能为该函数传入一个左值
②C++11 之后 有了一个重载版本
template&lt;typename T&gt;
class]]></description><category></category></item><item><title><![CDATA[1.1后续 Motivation for Move Semantics]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122468735</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122468735</guid><author>ZZHinclude</author><pubDate>Thu, 13 Jan 2022 11:30:16 +0800</pubDate><description><![CDATA[1.节约资源
通过上一次讲解，我们发现程序做了很多无意义的拷贝，如果能直接将那些要销毁的元素直接给新的元素，那不省去了很多事情吗？
没错C++11的移动语义，就是干这个事情的
2.C++11
①createAndInsert()； 函数
#include &lt;string&gt;
#include &lt;vector&gt;

std::vector&lt;std::string&gt; createAndInsert()
{

std::vector&lt;std::string&gt; coll;]]></description><category></category></item><item><title><![CDATA[1.1 Motivation for Move Semantics]]></title><link>https://blog.youkuaiyun.com/ZZHinclude/article/details/122466901</link><guid>https://blog.youkuaiyun.com/ZZHinclude/article/details/122466901</guid><author>ZZHinclude</author><pubDate>Thu, 13 Jan 2022 10:32:09 +0800</pubDate><description><![CDATA[1. Motivation for Move Semantics
为什么我们需要移动语义呢？
节约资源
就是这四个字 节约资源
2.C++03
①函数 createAndInsert()；
#include &lt;string&gt;
#include &lt;vector&gt;
std::vector&lt;std::string&gt; createAndInsert()
{
std::vector&lt;std::string&gt; coll; // 创建了一个元素是string的vector
]]></description><category></category></item></channel></rss>