随笔-90  评论-947  文章-0  trackbacks-0
 
     摘要: 引言 想搞正则表达式解析器好久了。前面由于一些基础设施没准备好,没法开始动手。现在 xlLib 里头准备的差不多了,可以着手实施了。   在做这件事之前,读了好几遍 @vczh 的文章《构造可配置词法分析器》《构造正则表达式引擎》(http://www.cppblog.com/vczh/archive/2008/05/22/50763.html),给了很大的帮助和启发,在这里表示感谢。(...  阅读全文
posted @ 2012-06-03 15:16 溪流 阅读(2381) | 评论 (7)编辑 收藏
     摘要: 对于 ScopeExit,以前有提到过(见《这种代码结构如何组织?goto or do…while(0)?》)。使用场景再简单提一下: bool GenFile() {     HANDLE hFile = CreateFile(_T("Test.txt"), GENERIC_WRITE, 0, NUL, CREATE_ALWAYS, 0, NULL);  ...  阅读全文
posted @ 2012-05-20 23:07 溪流 阅读(2294) | 评论 (7)编辑 收藏

以前做 Function 的时候恰好取巧避免掉了,这些天在做 Bind,不得已要把每个调用约定罗列一遍。顺手把这些东西复习一下,总结如下——

(所有内容针对 VC 编译平台)

 

一、x86

名称 传参方式 栈清理 C 语言函数重命名(例:int func(int, double))
__cdecl 从右至左压栈 主调函数 前面加“_”(_func)
__stdcall 从右至左压栈 被调函数 前面加“_”,后面加“@”再加参数十进制字节数(_func@12)
__fastcall 前两个不大于DWORD长度的参数从左至右分别存到 ECX、EDX,其余从右至左压栈 被调函数 前面加“@”,后面加“@”再加参数十进制字节数(@func@12)
__thiscall ECX 存 this,其余从右至左压栈 被调函数 仅用于 C++

 

二、x64

名称 传参方式 栈清理  
__fastcall 前四个整数/浮点数放在 RCX/XMM0、RDX/XMM1、R8/XMM2、R9/XMM3,其余压栈。
如果前 4 个参数分别为 int、float、long、double,它们将分别被存到 RCX、XMM1、R8、XMM3
被调函数  

64位编译环境下,可以指定 __cdecl、__stdcall、__fastcall,但是编译器会忽略它们。两个显示指定了不同调用约定的函数不构成重载,而构成重定义错误。

posted @ 2012-05-12 01:36 溪流 阅读(532) | 评论 (0)编辑 收藏
     摘要: 一直比较好奇 boost::bind 里面占位符和参数的顺序是怎么实现的,也一直看不太懂这方面源代码,昨晚好好看了下,终于有点弄懂了。小记一笔,与大家分享。 先看一个简单的用例: #include <boost/bind.hpp>   int foo(bool a, int b, double c) {     return 0; }  ...  阅读全文
posted @ 2012-04-21 15:01 溪流 阅读(3394) | 评论 (5)编辑 收藏

网上的文章但凡有提到 static_cast、const_cast、reinterpret_cast、dynamic_cast 的,都会语重心长的说,他们克服了 C 风格的类型转换的缺点,应当使用它们。

可是,C 风格的到底有什么坏处?C++的这些 cast 又有什么好处呢?

昨天以前,我连这些 cast 是什么都不知道(很惭愧)。昨天因为同事们提到这件事,于是小小研究了一下。一些实验代码如下:

 

1、无继承的类型转换

class A

{

 

};

 

class B

{

public:

    operator A()

    {

        return A();

    }

};

 

int main()

{

    B b;

    A a = (A)b;                     // 执行 operator A()

    A a2 = static_cast<A>(b);       // 执行 operator A()

    A a3 = dynamic_cast<A>(b);      // 不允许

    A a4 = reinterpret_cast<A>(b);  // 不允许

    A a5 = const_cast<A>(b);        // 不允许

   

    return 0;

}

 

2、const_cast

struct A

{

    int m;

 

    A(int m = 0) : m(m)

    {

 

    }

};

 

int main()

{

    const A a;

 

    A a2 = (A)a;        // 允许,(A) 有没有都一样,a2 是个新变量

    a2.m = 1;           // a2 的改变不影响 a

 

    A &a3 = (A &)a;     // 允许

    a3.m = 2;           // 影响 a

//  A &a4 = a;          // 不允许,const 限定起作用了

    A *pa5 = (A *)&a;   // 允许

    pa5->m = 3;         // 影响 a

//  A *pa6 = &a;        // 不允许,const 限定起作用了

 

//  A aa2 = const_cast<A>(a);       // 不允许

 

    A &aa3 = const_cast<A &>(a);    // 允许

    aa3.m = 2;                      // 影响 a

    A *paa5 = const_cast<A *>(&a);  // 允许

    paa5->m = 3;                    // 影响 a

 

    const int i = 0;

    const int &i2 = i;

    const int *pi3 = &i;

//  int j = const_cast<int>(i);         // 不允许

    int &j2 = const_cast<int &>(i2);    // 允许

    int *pj3 = const_cast<int *>(pi3);  // 允许

 

    return 0;

}

从第1点的试验,加上外界资料的说明,看上去const_case 只允许具有不同cv限定符的同类型之间的转换。

值得注意的是,如果类型A不是指针或引用,不能使用const_cast(使用了也无意义,见 A a2 = (A)a 这一行)

在 const_cast 可以使用的情形,(T)value 形式都可以使用,(T)value 在功能上完全覆盖 const_cast。

 

2、reinterpret_cast

class A

{

public:

    operator int *()

    {

        return nullptr;

    }

};

 

int main()

{

    int i = 0;

    double d = 1.0;

    int *p = nullptr;

   

//  int di = reinterpret_cast<int>(d);      // 不允许

    int pi = reinterpret_cast<int>(p);      // 允许

//  int pi2 = static_cast<int>(p);          // 不允许

//  double id = reinterpret_cast<double>(i);// 不允许

//  double pd = reinterpret_cast<double>(p);// 不允许

    int *ip = reinterpret_cast<int *>(i);   // 允许

//  int *ip2 = static_cast<int *>(i);       // 不允许

//  int *dp = reinterpret_cast<int *>(d);   // 不允许

 

    A a;

    int *pa = (int *)a;                     // 允许

    int *pa2 = static_cast<int *>(a);       // 允许

//  int *p2 = reinterpret_cast<int *>(a);   // 不允许

 

    return 0;

}

看上去,reinterpret_cast 可以理解为在指针和数值之间转换的一种方式,无关任何运算符重载,仅仅把指针转为字面值,或者把数字转为指针,转换的过程中值没有任何改变,只是告诉编译器不要报类型不匹配而已。

另外,在reinterpret_cast可以使用的情形,static_cast 是不可以使用的,除非定义了相应的类型转换运算符。

在 reinterpret_cast 可以使用的情形,(T)value 的方式同样可以完全胜任,(T)value 在功能上完全覆盖 reinterpret_cast。

 

dynamic_cast 我自认为还是理解的,就不试了。

 

综上,我的理解如下:

1static_cast + const_cast + reinterpret_cast = (T)value

C++ 把原来C风格的的这三个cast拆分成了三个,三者相互正交。大多数情况下,应该是 static_cast 在取代着 (T)value;只是在去除 cv 限定符的时候,换用 const_cast;在取指针字面值的时候,换用 reinterpret_cast。类型转换运算符 operator T() static_cast 负责执行。

2dynamic_cast C++ 新增的,用于多态的情形,且只允许转换具有多态关系的继承树上的类型的指针和引用,不允许转换类型本身。它不是针对 (T)value而出现的,两者没有任何竞争关系,只是取决于不同的需求。

(不知这样理解是否正确,请批评指正~)

至于网上推崇用新写法,是不是为了更细化而容易理解?有没有什么是 (T)value 做不到而 *_cast 能做到的?或者反过来?

posted @ 2012-03-23 09:53 溪流 阅读(1728) | 评论 (0)编辑 收藏
仅列出标题
共18页: First 3 4 5 6 7 8 9 10 11 Last