shootingstars

菩提本无树,明镜亦非台。本来无一物,何处惹尘埃。尘埃乃虚幻,亦何惧之来?

  博客园 :: 首页 :: 新随笔 :: 联系 :: 订阅 订阅 :: 管理 ::
  25 随笔 :: 0 文章 :: 36 评论 :: 0 Trackbacks

2007年8月13日 #

1 使用:
一直以来习惯了使用printf函数,但是对于可变参数没有深入研究过,觉得可变参数是一个神奇的技术^0^。。。
工作闲下来的时候,想研究研究看可变参数的使用和原理。
目前C提供的可变参数的申明为
void function(const char *format, ...);
这样就可以在function中使用可变参数
C提供了几个宏用于使用可变参数
va_list
va_start
va_arg
va_end
其中
va_list用于定义一个变量获取可变参数指针
va_start用于将va_list定义的指针进行初始化
va_arg用于获取对应指针的真实类型数据
va_end用于清空va_list定义的指针

好了,光说不练假把式,来一个例子吧。嗯,什么样的例子比较好呢?
对了,在c的printf中不支持c++的std::string,就自己实现一个支持std::string的printf吧。
例子:
Code

调用代码:
Code

输出结果为:
MyPrint Function Version:1, Support C++ std::string abc...version 2

可变参数真是神奇的很啊。。。

2 原理:
我们来看看这几个宏到底干了什么
typedef char *  va_list;  // 这个仅仅是个重定义而已。。。

// 获取v的地址
#define _ADDRESSOF(v)   ( &(v) )  
// n的整数字节的大小,必须是sizeof(int)的整数倍。如sizeof(n)为5的话,_INTSIZEOF(n)为8(假设为32位机器的话)
#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )
// 给v的地址加上v的大小  
#define va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )

// 给ap自增t的大小,并且获取原有ap的地址的数据,强制转型为t类型
// 这个相当于 ( *(t *)ap )
//            (ap += _INTSIZEOF(t))
// 这一个宏相当于完成两件事情
#define va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )

// 给ap置0
#define va_end(ap)      ( ap = (va_list)0 )

我们有必要了解一下C函数的调用规则了,在调用一个函数之前,调用方会将这个函数参数push(修改ESP指针),并且push规则是先push最后一个参数,最后push第一个参数,因此ESP指针最后应该是指向第一个参数。可变参数就是利用了这一点,一旦获取到第一个参数的地址后,就能够通过地址向前查找所有的参数。(注意:x86上的堆栈是反向的,push会使ESP的值减少,而不是增加)
上面的宏就是帮助用户查找所有的可变参数。

问题:
printf以及Printf都不是类型安全的。调用方必须保证参数个数的正确,以及参数类型的正确,否则将会发生不可预期的错误。

3 探索
是否可以写一个没有固定参数的函数,比如
int f (...);
据ANSI C说不行,但是我的vc8可行。
问题是写出这样的函数,va_start就用不上了,因为它需要可变参之前的那个固定参数。
其实我们可以自己从ESP中获取相关参数。
例子:
Code

调用代码:
Code


输出结果:
First=3
Second=5
Third=7

这样完全是可以获取第一个参数的地址的。问题是,由于没有类型信息和类型个数等信息(类似于printf中的%c等信息),所以这样的例子貌似意义不是很大。
posted @ 2008-07-30 14:05 shootingstars 阅读(25) | 评论 (0)编辑

int _stdcall s_addint(int i, int j)
{
    printf(
"i = %d\n",i);
    printf(
"j = %d\n",j);
    
return i+j;
}


int __cdecl  c_addint(int i, int j)
{
    printf(
"i = %d\n",i);
    printf(
"j = %d\n",j);
    
return i+j;
}


int _fastcall  f_addint(int i, int j, int k)
{
    printf(
"i = %d\n",i);
    printf(
"j = %d\n",j);
    printf(
"k = %d\n",k);
    
return i+j+k;
}


int _tmain(int argc, _TCHAR* argv[])
{
    
int num;

    
// 汇编调用_stdcall函数
    
// 参数由右至左压栈
    
// 调用返回时,堆栈由被调函数调整
    
// 返回值在EAX中
    _asm
    
{
        push 
2
        push 
1
        call s_addint
        mov  num,eax
    }


    printf(
"num = %d\n",num);

    
// 汇编调用__cdecl函数
    
// 参数由右至左压栈
    
// 调用返回时,堆栈由调用者调整
    
// 返回值在EAX中
    _asm
    
{
        push 
4
        push 
3
        call c_addint
        mov  num,eax
        add esp,
4*2
    }


    printf(
"num = %d\n",num);

    
// 汇编调用_fastcall函数
    
// 函数的第一个和第二个DWORD参数(或者尺寸更小的)通过ecx和edx传递,其他参数通过从右向左的顺序压栈
    
// 调用返回时,堆栈由被调函数调整
    
// 返回值在EAX中
    _asm
    
{
        mov ecx,
5
        mov edx,
6
        push 
7
        call f_addint
        mov  num,eax
    }


    printf(
"num = %d\n",num);
    
    
return 0;

}

 

以上代码通过VC8编译

 

posted @ 2008-07-22 13:52 shootingstars 阅读(31) | 评论 (0)编辑

在Java中,继承类可以使用super访问基类中的数据变量
class A
{
    
int i = -1;
}


class B extends A
{
    
void printSuperI()
    
{
        System.out.println(
super.i);
    }

}

但是在C++中,貌似没有此类访问符。。。
能否在C++中访问基类中的数据呢?当然能够,最简单的方式莫过于在基类中定义Get/Set等属性函数,在继承类中使用即可。
问题是,变量太多,定义n多的Get/Set看着有些烦人。
呵呵,其实可以采用一种不是很正规的方式来直接访问基类中的数据(注意:在真实的项目中不建议使用此类方法,这个方法仅仅用于对C++二进制布局的了解+测试而已。我目前已经用vc8、gcc测试通过)
我们知道,在C++中,基类和继承类对象其实享用的同一块内存空间。即this指针所指位置。我们的所有数据都在this指针所指位置上,所有数据按照内存正向规则向上占用各自的位置。

例子代码:
class A
{
public:
    
int i,j;
    A()
    
{
        i 
= -1;
        j 
= -2;
    }


}
;

class B : public A
{
public:
    
void printSuperI()
    
{
        
// 此this指针及指向A::i的内存位置
        int superI = *(int *)(this);   
        
// 此this+4指针及指向A::j的内存位置(sizeof(int) == 4)
        
// 注意:此时必须知道C++的内存对齐方案,当然你可以通过命令要求按照自己的规则进行内存对齐。
        int superJ = *(int *)((char*)this+4);  
        printf(
"SuperI=%d, superJ=%d\n",superI,superJ);
    }

}
;


问题:一旦在基类中出现了虚拟函数,此时的this指针不再指向数据的第一个变量,而是指向vptr。
在此种情况下需要给this指针加上一个vptr的指针变量位置即可。
class A
{
public:
    
int i;
    A()
    
{
        i 
= -1;
    }

    
virtual void foo()
    
{
        printf(
"Foo\n");
    }


}
;

class B : public A
{
public:
    
void printSuperI()
    
{
        
int superI = *(int *)((char*)this+4);
        printf(
"SuperI=%d\n",superI);
    }

}
;


补充:
既然知道了vptr的位置,那我们可以直接手工打造函数地址来调用它(我只使用vc8调用通过,gcc调用报错。。。)
vc的c++虚拟指针手工调用
class A
{
public:
    
int i;
    
char *p;
    A()
    
{
        p 
= "5678";
        i 
= -1;
    }

    
virtual void foo(const char *s)
    
{
        printf(
"Foo, %s : %s\n",s, p);
    }

    
virtual void foo1(const char *s)
    
{
        printf(
"Foo1, %s\n",s);
    }


}
;

typedef 
void (A::*foo_fun)(const char *p);

class B : public A
{
public:
    
void printSuperI()
    
{
        unsigned 
int *vptr;
        
int superI = *(int *)((char*)this+4);
        printf(
"SuperI=%d\n",superI);
        vptr 
= (unsigned int *)this;
        foo_fun fun_ptr 
= *(foo_fun*)(*vptr);
        (
this->*fun_ptr)("1234");
        foo_fun fun_ptr1 
= *(foo_fun*)((*vptr)+4);
        (
this->*fun_ptr1)("abcd");
    }

}
;

posted @ 2008-06-02 09:23 shootingstars 阅读(41) | 评论 (0)编辑

编译程序一般划分为
1 词法分析 -- 输入源程序,对源程序的字符串进行扫描和分解,得到一个个单词(token)
2 语法分析 -- 按照语法规则,确定输入串是否符合此规则
3 语义分析及中间代码产生 -- 在语法分析的基础上分析含义,并且进行相关的翻译(中间代码)。如很多编译器采用“四元式”作为中间代码,四元式如下所示:
    算符    左操作数    右操作数    结果
4 优化 -- 优化以上产生的中间代码,产生更加有效的中间代码
5 目标代码生成 -- 按照目标机产生低级语言代码

前端以及后端
前端 -- 与目标机无关的部分(词法分析,语法分析,语义分析,与目标机无关的中间代码优化)
后端 -- 与目标机有关的部分(与目标机相关的中间代码优化以及目标代码生成)

posted @ 2008-05-07 18:43 shootingstars 阅读(43) | 评论 (0)编辑

以前使用bind1st以及bind2nd很少,后来发现这两个函数还挺好玩的,于是关心上了。
在C++ Primer对于bind函数的描述如下:

绑定器binder通过把二元函数对象的一个实参绑定到一个特殊的值上将其转换成一元函数对象

C++标准库提供了两种预定义的binder 适配器bind1st 和bind2nd 正如你所预料的bind1st 把值绑定到二元函数对象的第一个实参上bind2nd 把值绑定在第二个实参上
例如
为了计数容器中所有小于或等于10 的元素的个数我们可以这样向count_if()传递
count_if( vec.begin(), vec.end(), bind2nd( less_equal<int>(), 10 ));


哦,这倒是挺有意思的。于是依葫芦画瓢:
bool print(int i, int j) 
{
    std::cout
<< i << "---" << j << std::endl; 
    
return i>j;
}

int main(int argc, char *argv[])
{
    (std::bind1st(print, 
2))(1);
    
return 0;

}
满怀希望它能够打印
2---1

只不过。。。编译出错:
1    Error    error C2784: 'std::binder1st<_Fn2> std::bind1st(const _Fn2 &,const _Ty &)' : could not deduce template argument for 'overloaded function type' from 'overloaded function type'   
---不能够推断出模板参数for 'overloaded function type' from 'overloaded function type' 。。。。
(还真看不明白。。。)

于是直接看bind1st代码:
template<class _Fn2,
    
class _Ty> inline
    binder1st
<_Fn2> bind1st(const _Fn2& _Func, const _Ty& _Left)
        {    
        typename _Fn2::first_argument_type _Val(_Left);
        
return (std::binder1st<_Fn2>(_Func, _Val));
        }
嗯。。。在代码里

typename _Fn2::first_argument_type _Val(_Left)
说必须定义
first_argument_type类型,可是我一个函数,哪里来的这个类型定义?嗯,STL一定提供了某种东东用来自动定义这个类型。找啊找,于是找到了ptr_fun。
这个函数自动将一个函数指针转换为一个binary_function的继承类pointer_to_binary_function,而在
binary_function中定义了first_argument_type。
于是修改代码:
int main(int argc, char *argv[])
{
    (std::bind1st(std::ptr_fun(print), 
2))(1);
    
return 0;
}
打印结果如下:
2---1
posted @ 2007-08-17 17:35 shootingstars 阅读(363) | 评论 (1)编辑

最近公司版本管理日显复杂,急需进行每日构建来确保版本质量。于是想到了用python开发一个简单的每日构建工具进行自动代码切出,自动编译以及自动打包。

写了好几天,基本成果出来了。用一个XML文件控制所有的代码切出,编译以及打包过程。
公司的软件涉及到了C++,Java和C#,C++和C#都是用的Vs2005,这个好说,用Vs2005自带的命令行方式编译项目即可。但是Java开发用的是Eclipse,没有听说Eclipse自己带命令行方式的,同事推荐使用ANT,于是研究了以下ANT的配置方式。。。天哪。。。我写的那个每日构建工具基本上用ANT都可以实现。。。
郁闷,早知道,也没必要花好几天时间,直接拿ANT来用就好了。。。

不过好在发现自己写的东东与ANT的很多东西不谋而合,也算心里有点安慰了。

附上一个python的学习文档,俺就是看着它上手的:Python 研究(Dive Into Python)

posted @ 2007-08-13 14:41 shootingstars 阅读(188) | 评论 (0)编辑