宏
来源:互联网 发布:悦木之源什么档次知乎 编辑:程序博客网 时间:2024/05/02 02:08
1>关于图形
。这个例子摘自《C专家编程》。 根据位模式构建图形图标(icon)或者图形(glyph),是一种小型的位模式映射于屏幕产生的图像。一个位代表图像上的一个像素。如果一个位被设置,那么它所代表的像素就是“亮”的。如果一个位被清除,那么它所代表的像素就是“暗”的。所以,一系列的整数值能够用于为图像编码。类似Iconedit这样的工具就是用于绘图的,他们所输出的是一个包含一系列整型数的ASCII文件,可以被一个窗口程序所包含。它所存在的问题是程序中的图标只是一串十六进制数。在C语言中,典型的16X16的黑白图形可能如下:
0x07C6,
0x1FF7,
0x383B,
0x600C,
0x600C,
0xC006,
0xC006,
0xDF06,
0xC106,
0xC106,
0x610C,
0x610C,
0x3838,
0x1FF0,
0x07C0,
0x0000
};
正如所看到的那样,这些C语言常量并未有提供有关图形实际模样的任何线索。这里有一个惊人的#define定义的优雅集合,允许程序建立常量使它们看上去像是屏幕上的图形。
#define _ )*2
#define s ((((((((((((((((0 /* For building glyphs 16 bits wide */
定义了它们之后,只要画所需要的图标或者图形等,程序会自动创建它们的十六进制模式。使用这些宏定义,程序的自描述能力大大加强,上面这个例子可以转变为:
{
s _ _ _ _ _ X X X X X _ _ _ X X _ ,
s _ _ _ X X X X X X X X X _ X X X ,
s _ _ X X X _ _ _ _ _ X X X _ X X ,
s _ X X _ _ _ _ _ _ _ _ _ X X _ _ ,
s _ X X _ _ _ _ _ _ _ _ _ X X _ _ ,
s X X _ _ _ _ _ _ _ _ _ _ _ X X _ ,
s X X _ _ _ _ _ _ _ _ _ _ _ X X _ ,
s X X _ X X X X X _ _ _ _ _ X X _ ,
s X X _ _ _ _ _ X _ _ _ _ _ X X _ ,
s X X _ _ _ _ _ X _ _ _ _ _ X X _ ,
s _ X X _ _ _ _ X _ _ _ _ X X _ _ ,
s _ X X _ _ _ _ X _ _ _ _ X X _ _ ,
s _ _ X X X _ _ _ _ _ X X X _ _ _ ,
s _ _ _ X X X X X X X X X _ _ _ _ ,
s _ _ _ _ _ X X X X X _ _ _ _ _ _ ,
s _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _
};
解释:每一位乘以2表示向左移1位,可以把乘以二的提取出来,转换成0*2*2*2*2*2**2*2(15个)+1*2*2*2*22*2*2*(14个)+1*2*2*2*(13个)……0*2+1*1(0个即1),第一位的0或1表示_和X并一一对应上。
显然,与前面的代码相比,它的意思更为明显。标准的C语言具有八进制、十进制和十六进制常量,但没有二进制常量,否则的话倒是一种更为简单的绘制图形模式的方法。
2>关于对地址直接赋值操作
在ARM中看到了 #define rWTCON (*(volatile unsigned *)0x03000000)然后在函数调用中对这地址直接赋值,rWTCON = (PCLK / (100000-1)<<8 | (3<<3));
刚看到这吓我一跳,以前只听说过没有看过,这里还真这样干了,这就是c语言中的直接对内存赋值,以上的语句还真有特色,这样用了宏还在下面移位操作,运用的这么规范化
,比如我们要将某数中间的第7,6,5位分别置011(假设这数先被初始化为0) 这个一般不是x |=0x01100000;而是这样x |= (3<<5);好处在于,十进制比十六进制更方便看,方便检查。
#include <stdio.h>int main(){void (* signal (int sign, void(*handler)(int))) (int);//也可以写成这样
void (* signal (int , void(* )(int))) (int);
* (volatile unsigned *)0x0012ff7c = 0x12345;
printf("%x\n",* (volatile unsigned *)0x0012ff7c);return 0;}vc编译通过,值得注意得是上面指针的声明,这就是高级指针声明,指针乃C语言精华
这里补上一个问题,测结构体某个成员相对于结构体首地址的偏移量,看看书上是怎么测的,
#define offsetof(s,m) (size_t) & (((s *)0)->m)s 是结构体的类型,m是其中的成员,利用强制转换 和0地址的巧妙使用,size_t是typedef unsigned int size_t;这些东西是不是你只是看得懂而用不出来呢。
对这个问题有三种基本的反应
1)不知道如何下手。该被面者从没做过任何嵌入式系统的工作。
2) 用bit fields。Bit fields是被扔到C语言死角的东西,它保证你的代码在不同编译器之间是不可移植的,同时也保证了的你的代码是不可重用的。我最近不幸看到 Infineon为其较复杂的通信芯片写的驱动程序,它用到了bit fields因此完全对我无用,因为我的编译器用其它的方式来实现bit fields的。从道德讲:永远不要让一个非嵌入式的家伙粘实际硬件的边。
3) 用 #defines 和 bit masks 操作。这是一个有极高可移植性的方法,是应该被用到的方法。最佳的解决方案如下:
知道为什么不方便移植么,那就是机子的 int 到底分配几个字节空间 当然这只是我的理解,暂时持保留态度,其他文字是转载
#define BIT3 (0x1 << 3)
static int a;
void set_bit3(void)
{
a |= BIT3;
}
void clear_bit3(void)
{
a &= ~BIT3;
}
一些人喜欢为设置和清除值而定义一个掩码同时定义一些说明常数,这也是可以接受的。我希望看到几个要点:说明常数、|=和&=~操作。
5>关于可变形参 ... 的实现
va_list、va_start、va_arg、va_end的原理与使用
- 概述
由于在C语言中没有函数重载,解决不定数目函数参数问题变得比较麻烦;即使采用C++,如果参数个数不能确定,也很难采用函数重载.对这种情况,有些人采用指针参数来解决问题.下面就c语言中处理不定参数数目的问题进行讨论. - 定义
大家先看几宏.
在VC++6.0的include有一个stdarg.h头文件,有如下几个宏定义:
#define _INTSIZEOF(n) ((sizeof(n)+sizeof(int)-1)&~(sizeof(int) - 1) )
#define va_start(ap,v) ( ap = (va_list)&v + _INTSIZEOF(v) ) //第一个可选参数地址
#define va_arg(ap,t) ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) ) //下一个参数地址
#define va_end(ap) ( ap = (va_list)0 ) // 将指针置为无效
如果对以上几个宏定义不理解,可以略过,接这看后面的内容. - 参数在堆栈中分布,位置
在进程中,堆栈地址是从高到低分配的.当执行一个函数的时候,将参数列表入栈,压入堆栈的高地址部分,然后入栈函数的返回地址,接着入栈函数的执行代码,这个入栈过程,堆栈地址不断递减,一些黑客就是在堆栈中修改函数返回地址,执行自己的代码来达到执行自己插入的代码段的目的.
总之,函数在堆栈中的分布情况是:地址从高到低,依次是:函数参数列表,函数返回地址,函数执行代码段.
堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
最后一个参数
倒数第二个参数
...
第一个参数
函数返回地址
函数代码段 - 示例代码
void arg_test(int i, ...);
int main(int argc,char *argv[])
{
int int_size = _INTSIZEOF(int);
printf("int_size=%d\n", int_size);
arg_test(0, 4);
arg_cnt(4,1,2,3,4);
return 0;
}
void arg_test(int i, ...)
{
int j=0;
va_list arg_ptr;
va_start(arg_ptr, i);
printf("&i = %p\n", &i);//打印参数i在堆栈中的地址
printf("arg_ptr = %p\n", arg_ptr);
//打印va_start之后arg_ptr地址,
//应该比参数i的地址高sizeof(int)个字节
//这时arg_ptr指向下一个参数的地址
j=*((int *)arg_ptr);
printf("%d %d\n", i, j);
j=va_arg(arg_ptr, int);
printf("arg_ptr = %p\n", arg_ptr);
//打印va_arg后arg_ptr的地址
//应该比调用va_arg前高sizeof(int)个字节
//这时arg_ptr指向下一个参数的地址
va_end(arg_ptr);
printf("%d %d\n", i, j);
} - 代码说明:
int int_size = _INTSIZEOF(int);得到int类型所占字节数
va_start(arg_ptr, i); 得到第一个可变参数地址,根据定义(va_list)&v得到起始参数的地址, 再加上_INTSIZEOF(v) ,就是其实参数下一个参数的地址,即第一个可变参数地址.
j=va_arg(arg_ptr, int); 得到第一个参参数的值,并且arg_ptr指针上移一个_INTSIZEOF(int),即指向下一个可变参数的地址.
va_end(arg_ptr);置空arg_ptr,即arg_ptr=0;
总结:读取可变参数的过程其实就是堆栈中,使用指针,遍历堆栈段中的参数列表,从低地址到高地址一个一个地把参数内容读出来的过程. - 在编程中应该注意的问题和解决办法
虽然可以通过在堆栈中遍历参数列表来读出所有的可变参数,但是由于不知道可变参数有多少个,什么时候应该结束遍历,如果在堆栈中遍历太多,那么很可能读取一些无效的数据.
解决办法:a.可以在第一个起始参数中指定参数个数,那么就可以在循环还中读取所有的可变参数;b.定义一个结束标记,在调用函数的时候,在最后一个参数中传递这个标记,这样在遍历可变参数的时候,可以根据这个标记结束可变参数的遍历;
下面是一段示例代码:
//第一个参数定义可选参数个数,用于循环取初参数内容
void arg_cnt(int cnt, ...);
int main(int argc,char *argv[])
{
int int_size = _INTSIZEOF(int);
printf("int_size=%d\n", int_size);
arg_cnt(4,1,2,3,4);
return 0;
}
void arg_cnt(int cnt, ...)
{
int value=0;
int i=0;
int arg_cnt=cnt;
va_list arg_ptr;
va_start(arg_ptr, cnt);
for(i = 0; i < cnt; i++)
{
value = va_arg(arg_ptr,int);
printf("value%d=%d\n", i+1, value);
}
}
虽然可以根据上面两个办法解决读取参数个数的问题,但是如果参数类型都是不定的,该怎么办,如果不知道参数的类型,即使读到了参数也没有办法进行处理.解决办法:可以自定义一些可能出现的参数类型,这样在可变参数列表中,可以可变参数列表中的那类型,然后根据类型,读取可变参数值,并进行准确地转换.传递参数的时候可以这样传递:参数数目,可变参数类型1,可变参数值1,可变参数类型2,可变参数值2,....
这里给出一个完整的例子:
#include <stdio.h>
#include <stdarg.h>
const int INT_TYPE = 100000;
const int STR_TYPE = 100001;
const int CHAR_TYPE = 100002;
const int LONG_TYPE = 100003;
const int FLOAT_TYPE = 100004;
const int DOUBLE_TYPE = 100005;
//第一个参数定义可选参数个数,用于循环取初参数内容
//可变参数采用arg_type,arg_value...的形式传递,以处理不同的可变参数类型
void arg_type(int cnt, ...);
//第一个参数定义可选参数个数,用于循环取初参数内容
void arg_cnt(int cnt, ...);
//测试va_start,va_arg的使用方法,函数参数在堆栈中的地址分布情况
void arg_test(int i, ...);
int main(int argc,char *argv[])
{
int int_size = _INTSIZEOF(int);
printf("int_size=%d\n", int_size);
arg_test(0, 4);
arg_cnt(4,1,2,3,4);
arg_type(2, INT_TYPE, 222, STR_TYPE, "ok,hello world!");
return 0;
}
void arg_test(int i, ...)
{
int j=0;
va_list arg_ptr;
va_start(arg_ptr, i);
printf("&i = %p\n", &i);//打印参数i在堆栈中的地址
printf("arg_ptr = %p\n", arg_ptr);
//打印va_start之后arg_ptr地址,
//应该比参数i的地址高sizeof(int)个字节
//这时arg_ptr指向下一个参数的地址
j=*((int *)arg_ptr);
printf("%d %d\n", i, j);
j=va_arg(arg_ptr, int);
printf("arg_ptr = %p\n", arg_ptr);
//打印va_arg后arg_ptr的地址
//应该比调用va_arg前高sizeof(int)个字节
//这时arg_ptr指向下一个参数的地址
va_end(arg_ptr);
printf("%d %d\n", i, j);
}
void arg_cnt(int cnt, ...)
{
int value=0;
int i=0;
int arg_cnt=cnt;
va_list arg_ptr;
va_start(arg_ptr, cnt);
for(i = 0; i < cnt; i++)
{
value = va_arg(arg_ptr,int);
printf("value%d=%d\n", i+1, value);
}
}
void arg_type(int cnt, ...)
{
int arg_type = 0;
int int_value=0;
int i=0;
int arg_cnt=cnt;
char *str_value = NULL;
va_list arg_ptr;
va_start(arg_ptr, cnt);
for(i = 0; i < cnt; i++)
{
arg_type = va_arg(arg_ptr,int);
switch(arg_type)
{
case INT_TYPE:
int_value = va_arg(arg_ptr,int);
printf("value%d=%d\n", i+1, int_value);
break;
case STR_TYPE:
str_value = va_arg(arg_ptr,char*);
printf("value%d=%d\n", i+1, str_value);
break;
default:
break;
}
}
}
以上是我个人的见解,不对的地方希望大家指正,发表看法,我不胜感谢!!!
posted on 2008-01-21 15:30 浪迹天涯 阅读(28089) 评论(11) 编辑 收藏 引用 所属分类: C++
摘自http://www.cppblog.com/qiujian5628/archive/2008/01/21/41562.html
--摘录自自己整理
- 宏
- 宏
- ##宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 宏
- 泛型 -- 关于方法的类型约束
- struts2+hibernate+spring2+jquery+ajax+div+css小型项目供初学者参考
- P05: 二维费用的背包问题
- Java生成javadoc
- Win7安vc2008编译报LINK : fatal error LNK1000: Internal error during IncrBuildImage[转]
- 宏
- DatePickerDialog
- 笑话二 -- 冷 收集.
- 黑马程序员--多线程
- SQL中多表连接组合更新的问题
- 英语中容易混淆的单词发音: 一
- win7 or win 2008
- 图灵奖史上最年轻获奖者高德纳:把一件平常事做到人间极致(转)
- PHP 批量生成静态html
评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2008-01-21 15:30 浪迹天涯
va_start() va_end()函数应用
1:当无法列出传递函数的所有实参的类型和数目时,可用省略号指定参数表
void foo(...);
void foo(parm_list,...);
2:函数参数的传递原理
函数参数是以数据结构:栈的形式存取,从右至左入栈.eg:
#include <iostream>
void fun(int a, ...)
{
int *temp = &a;
temp++;
for (int i = 0; i < a; ++i)
{
cout << *temp << endl;
temp++;
}
}
int main()
{
int a = 1;
int b = 2;
int c = 3;
int d = 4;
fun(4, a, b, c, d);
system("pause");
return 0;
}
Output::
1
2
3
4
3:获取省略号指定的参数
在函数体中声明一个va_list,然后用va_start函数来获取参数列表中的参数,使用完毕后调用va_end()结束。像这段代码:
void TestFun(char* pszDest, int DestLen, const char* pszFormat, ...)
{
va_list args;
va_start(args, pszFormat);
_vsnprintf(pszDest, DestLen, pszFormat, args);
va_end(args);
}
4.va_start使argp指向第一个可选参数。va_arg返回参数列表中的当前参数并使argp指向参数列表中的下一个参数。va_end把argp指针清为NULL。函数体内可以多次遍历这些参数,但是都必须以va_start开始,并以va_end结尾。
1).演示如何使用参数个数可变的函数,采用ANSI标准形式
#include 〈stdio.h〉
#include 〈string.h〉
#include 〈stdarg.h〉
/*函数原型声明,至少需要一个确定的参数,注意括号内的省略号*/
int demo( char, ... );
void main( void )
{
demo("DEMO", "This", "is", "a", "demo!", "");
}
/*ANSI标准形式的声明方式,括号内的省略号表示可选参数*/
int demo( char msg, ... )
{
/*定义保存函数参数的结构*/
va_list argp;
int argno = 0;
char para;
/*argp指向传入的第一个可选参数,msg是最后一个确定的参数*/
va_start( argp, msg );
while (1)
{
para = va_arg( argp, char);
if ( strcmp( para, "") == 0 )
break;
printf("Parameter #%d is: %s\n", argno, para);
argno++;
}
va_end( argp );
/*将argp置为NULL*/
return 0;
}
2)//示例代码1:可变参数函数的使用
#include "stdio.h"
#include "stdarg.h"
void simple_va_fun(int start, ...)
{
va_list arg_ptr;
int nArgValue =start;
int nArgCout=0; //可变参数的数目
va_start(arg_ptr,start); //以固定参数的地址为起点确定变参的内存起始地址。
do
{
++nArgCout;
printf("the %d th arg: %d\n",nArgCout,nArgValue); //输出各参数的值
nArgValue = va_arg(arg_ptr,int); //得到下一个可变参数的值
} while(nArgValue != -1);
return;
}
int main(int argc, char* argv[])
{
simple_va_fun(100,-1);
simple_va_fun(100,200,-1);
return 0;
}
3)//示例代码2:扩展——自己实现简单的可变参数的函数。
下面是一个简单的printf函数的实现,参考了<The C Programming Language>中的例子
#include "stdio.h"
#include "stdlib.h"
void myprintf(char* fmt, ...) //一个简单的类似于printf的实现,//参数必须都是int 类型
{
char* pArg=NULL; //等价于原来的va_list
char c;
pArg = (char*) &fmt; //注意不要写成p = fmt !!因为这里要对//参数取址,而不是取值
pArg += sizeof(fmt); //等价于原来的va_start
do
{
c =*fmt;
if (c != '%')
{
putchar(c); //照原样输出字符
}
else
{
//按格式字符输出数据
switch(*++fmt)
{
case'd':
printf("%d",*((int*)pArg));
break;
case'x':
printf("%#x",*((int*)pArg));
break;
default:
break;
}
pArg += sizeof(int); //等价于原来的va_arg
}
++fmt;
}while (*fmt != '\0');
pArg = NULL; //等价于va_end
return;
}
int main(int argc, char* argv[])
{
int i = 1234;
int j = 5678;
myprintf("the first test:i=%d\n",i,j);
myprintf("the secend test:i=%d; %x;j=%d;\n",i,0xabcd,j);
system("pause");
return 0;
}
回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2009-05-14 08:05 ForE
多谢!
描述上有点问题
-----------------------
堆栈中,各个函数的分布情况是倒序的.即最后一个参数在列表中地址最高部分,第一个参数在列表地址的最低部分.参数在堆栈中的分布情况如下:
最后一个参数
倒数第二个参数
...
第一个参数
函数返回地址
函数代码段
---------------------
stdcall才是这种情况...
回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2009-06-09 13:53 code c
经典!!! 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2009-06-09 14:07 code c
int demo( char msg, ... )
这个函数有个小问题(应该是char *,而不是char ),应改为:
/*ANSI标准形式的声明方式,括号内的省略号表示可选参数*/
int demo(char* msg, ...)
{
/*定义保存函数参数的结构*/
va_list argp;
int argno = 0;
char* para;
/*argp指向传入的第一个可选参数,msg是最后一个确定的参数*/
va_start(argp, msg);
while (1)
{
para = va_arg(argp, char*);
if (strcmp(para, "") == 0)
break;
printf("Parameter #%d is: %s\n", argno, para);
argno++;
}
va_end(argp);
/*将argp置为NULL*/
return 0;
}
回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2010-02-08 21:05 chhaya
好! 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2010-04-15 11:29 某某
谢谢分享,很详细
也是,参数压栈顺序好像有两种啊 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2010-05-14 17:43 Delacroix
函数的代码段是不放在堆栈里的。所有的执行代码都是放在统一的代码段里的。 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2010-07-01 16:09 suohd
@Delacroix
这点我同意。 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2010-07-08 13:39 leobupt
@code c
demo()函数有几处错误,修改如下:
int demo( char *msg, ... )
{
/*定义保存函数参数的结构*/
va_list argp;
int argno = 0;
char *para; //char para;
/*argp指向传入的第一个可选参数,msg是最后一个确定的参数*/
va_start( argp, msg );
while (1)
{
para = va_arg( argp, char*);//para = va_arg( argp, char);
if (strcmp(para, "") == 0 )
break;
printf("Parameter #%d is: %s\n", argno, para);
argno++;
}
va_end(argp);
//va_end( argp );
/*将argp置为NULL*/
return 0;
} 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用 2011-03-08 16:35 cxm240
最后一个参数
倒数第二个参数
...
第一个参数
函数返回地址
函数代码段
最后压栈的不是函数代码段,而是该函数的栈帧ebp 回复 更多评论
# re: va_list、va_start、va_arg、va_end的原理与使用[