C 详解C语言中的宏定义

最新推荐文章于 2024-07-10 07:23:36 发布
最新推荐文章于 2024-07-10 07:23:36 发布
阅读量1.1k 收藏
点赞数
分类专栏： C/C++ 文章标签： 宏定义

宏定义的基本用法

无参宏定义：

无参宏定义的一般形式为： #define 标识符 字符串
其中的“#”表示这是一条预处理命令。凡是以“#”开头的均为预处理命令。“define”为宏定义命令。“标识符”为所定义的宏名。“字符串”可以是常数、表达式、格式串等。
例如：　#define M (a+b)　它的作用是指定 标识符M来代替 表达式(a+b)。在编写 源程序时，所有的(a+b)都可由M代替，而对源程序作编译时，将先由预处理程序进行宏代换，即用(a+b) 表达式去置换所有的宏名M，然后再进行编译。 
#include<stdio.h>
#defineM(a+b)
intmain(intargc,char*argv[])
{
ints,a,b;
printf("inputnumbera&b:");
scanf("%d%d",&a,&b);
s=M*M;
printf("s=%d\n",s);
}

上例程序中首先进行 宏定义 ，定义M来替代 表达式 (a+b),在 s= M * M 中作了宏调用。在预处理时经宏展开后该语句变为： S=(a+b)*(a+b) 　但要注意的是，在 宏定义 中 表达式 (a+b)两边的括号不能少。否则会发生错误。 　如当作以下定义后：#define M (a)+(b) 　在宏展开时将得到下述语句：S= (a)+(b)*(a)+(b)

带参宏定义：

c语言允许宏带有参数。在 宏定义中的参数称为 形式参数，在宏调用中的参数称为 实际参数。对带参数的宏，在调用中，不仅要宏展开，而且要用 实参去代换 形参。
带参 宏定义的一般形式为： 　 #define 宏名( 形参表) 字符串
在字符串中含有各个 形参。 带参宏调用的一般形式为： 　 宏名( 形参表)
例如： 
<span style="font-size:12px;">#defineM(y)((y)*(y)+3*(y))/*宏定义*/
    k=M(5);/*宏调用*/</span>
在宏调用时，用 实参 5去代替 形参 y，经预处理宏展开后的语句为: 　k=5*5+3*5 

//#include<cstdio>
#include<stdio.h>
#defineMAX(a,b)((a>b)?(a):(b))
intmain(intargc,char*argv[])
{
intx,y,max;
printf("inputtwonumbers:");
scanf("%d%d",&x,&y);
max=MAX(x,y);
printf("max=%d\n",max);
return0;
}

上例程序的第一行进行带参 宏定义，用宏名MAX表示条件表达式 (a>b)?a:b ， 形参a,b均出现在条件表达式中。程序中 max=MAX(x,y) 为宏调用， 实参x,y，将代换 形参a,b。宏展开后该语句为： max=(x>y)?x:y; 　用于计算x,y中的大数。
#define  条件编译
头文件(.h)可以被头文件或C文件包含；重复包含（重复定义）由于头文件包含可以嵌套，那么C文件就有可能包含多次同一个头文件，就可能出现重复定义的问题的。 通过 条件编译开关来避免重复包含（重复定义）
例如 
#ifndef__headerfileXXX__
#define__headerfileXXX__
//文件内容
#endif

宏定义的特殊用法

1. 防止一个头文件被重复包含

#ifndef COMDEF_H 
#define COMDEF_H 
//头文件内容 
#endif

2. 重新定义一些类型,防止由于各种平台和编译器的不同,而产生的类型字节数差异,方便移植。 

typedef  unsigned char      boolean;     /* Boolean value type. */ 
typedef  unsigned long int  uint32;      /* Unsigned 32 bit value */ 
typedef  unsigned short     uint16;      /* Unsigned 16 bit value */ 
typedef  unsigned char      uint8;       /* Unsigned 8  bit value */ 
typedef  signed long int    int32;       /* Signed 32 bit value */ 
typedef  signed short       int16;       /* Signed 16 bit value */ 
typedef  signed char        int8;        /* Signed 8  bit value */

3. 得到指定地址上的一个字节或字  

#define  MEM_B( x )  ( *( (int8 *) (x) ) ) 
#define  MEM_W( x )  ( *( (uint16 *) (x) ) )

4. 求最大值和最小值 
    会存在Duplication of Side Effects问题。这里的Side Effect是指宏在展开的时候对其参数可能进行多次Evaluation(也就是取值)，但是如果这个宏参数是一个函数，那么就有可能被调用多次从而达到不一致的结果，甚至会发生更严重的错误。比如： 

#define  MAX( x, y ) ( ((x) > (y)) ? (x) : (y) ) 
#define  MIN( x, y ) ( ((x) < (y)) ? (x) : (y) ) 
c = min(a,foo(b));

这时foo()函数就被调用了两次。为了解决这个潜在的问题，我们应当这样写min(X,Y)这个宏： 

#define min(X,Y) ({\
typeof (X) x_ = (X);\
typeof (Y) y_ = (Y);\
(x_ < y_) ? x_ : y_; })

({...})的作用是将内部的几条语句中最后一条的值返回，它也允许在内部声明变量(因为它通过大括号组成了一个局部Scope)

5,得到一个field在结构体(struct)中的偏移量 

#define FPOS( type, field ) ( (dword) &(( type *) 0)-> field )

6,得到一个结构体中field所占用的字节数 

#define FSIZ( type, field ) sizeof( ((type *) 0)->field )

7,按照LSB格式把两个字节转化为一个Word  

#define  FLIPW( ray ) ( (((word) (ray)[0]) * 256) + (ray)[1] )

8,按照LSB格式把一个Word转化为两个字节 

#define<span style="white-space:pre">	</span>FLOPW( ray, val ) \ 
<span style="white-space:pre">	</span>(ray)[0] = ((val) / 256); \ 
<span style="white-space:pre">	</span>(ray)[1] = ((val) & 0xFF)

9,得到一个变量的地址(word宽度)  

#define  B_PTR( var )  ( (int8 *) (void *) &(var) ) 
#define  W_PTR( var )  ( (uint16 *) (void *) &(var) )

10,得到一个字的高位和低位字节 

#define  WORD_LO(xxx)  ((byte) ((uint16)(xxx) & 255)) 
#define  WORD_HI(xxx)  ((byte) ((uint16)(xxx) >> 8))

11,返回一个比X大的最接近的8的倍数 

#define RND8( x )       ((((x) + 7) / 8 ) * 8 )

12,将一个字母转换为大写 

#define  UPCASE( c ) ( ((c) >= ''a'' && (c) <= ''z'') ? ((c) - 0x20) : (c) )

13,判断字符是不是10进值的数字 

#define  DECCHK( c ) ((c) >= ''0'' && (c) <= ''9'')

14,判断字符是不是16进值的数字 

#define  HEXCHK( c ) ( ((c) >= ''0'' && (c) <= ''9'') ||\ 
                       ((c) >= ''A'' && (c) <= ''F'') ||\ 
		       ((c) >= ''a'' && (c) <= ''f'') )

15,防止溢出的一个方法 

#define  INC_SAT( val )  (val = ((val)+1 > (val)) ? (val)+1 : (val))


16,返回数组元素的个数  

#define  ARR_SIZE( a )  ( sizeof( (a) ) / sizeof( (a[0]) ) )


17,返回一个无符号数n尾的值

MOD_BY_POWER_OF_TWO(X,n)=X%(2^n) 

#define MOD_BY_POWER_OF_TWO( val, mod_by ) \ 
           ( (dword)(val) & (dword)((mod_by)-1) )

18,对于IO空间映射在存储空间的结构,输入输出处理 

#define inp(port)         (*((volatile byte *) (port))) 
#define inpw(port)        (*((volatile word *) (port))) 
#define inpdw(port)       (*((volatile dword *)(port))) 
#define outp(port, val)   (*((volatile byte *) (port)) = ((byte) (val))) 
#define outpw(port, val)  (*((volatile word *) (port)) = ((word) (val))) 
#define outpdw(port, val) (*((volatile dword *) (port)) = ((dword) (val)))

19. 使用一些宏跟踪调试 
ANSI标准说明了五个预定义的宏名。它们是： 
_LINE_
_FILE_ 
_DATE_ 
_TIME_ 
_STDC_ 
如果编译不是标准的,则可能仅支持以上宏名中的几个,或根本不支持。记住编译程序也许还提供其它预定义的宏名。 
_LINE_标识当前代码所在的行号
_FILE_标识代码所在的文件名
_DATE_宏指令含有形式为月/日/年的串,表示源文件被翻译到代码时的日期。 
源代码翻译到目标代码的时间作为串包含在_TIME_中。串形式为时：分：秒。 
如果实现是标准的,则宏_STDC_含有十进制常量1。如果它含有任何其它数,则实现是非标准的。 

可以定义宏,例如: 
当定义了_DEBUG,输出数据信息和所在文件所在行  

#ifdef _DEBUG 
#define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%d”,date,_LINE_,_FILE_) 
#else 
#define DEBUGMSG(msg,date) 
#endif

20. 宏定义防止使用是错误用小括号包含。 
例如： 

#define ADD(a,b) (a+b)

用do{}while(0)语句包含多语句防止错误 
例如： 

#difne DO(a,b) a+b; a++;

应用时： 

if(...) 
DO(a,b); //产生错误 
else 
...

解决方法: 

#define DO(a,b) do{a+b;a++;}while(0)

21. 宏中"#"和"##"的用法
#的功能是将其后面的宏参数进行字符串化操作(Stringfication)。
##被称为连接符(concatenator)，用来将两个Token连接为一个Token。注意这里连接的对象是Token就行，而不一定是宏的变量。
用法:  

#include<cstdio> 
#include<climits> 
using namespace std; 

#define STR(s)     #s 
#define CONS(a,b)  int(a##e##b) 

int main() 
{ 
    printf(STR(vck));           // 输出字符串"vck" 
    printf("%d\n", CONS(2,3));  // 2e3 输出:2000 
    return 0; 
}

当宏参数是另一个宏的时候，需要注意的是凡宏定义里有用''#''或''##''的地方宏参数是不会再展开. 
1) 非''#''和''##''的情况  

#define TOW      (2) 
#define MUL(a,b) (a*b) 
printf("%d*%d=%d\n", TOW, TOW, MUL(TOW,TOW));

这行的宏会被展开为： 

printf("%d*%d=%d\n", (2), (2), ((2)*(2)));

MUL里的参数TOW会被展开为(2). 

2) 当有''#''或''##''的时候 

#define A          (2) 
#define STR(s)     #s 
#define CONS(a,b)  int(a##e##b) 
printf("int max: %s\n",  STR(INT_MAX));    // INT_MAX #include<climits>

这行会被展开为： 

printf("int max: %s\n", "INT_MAX"); 

printf("%s\n", CONS(A, A));               // compile error

这一行则是： 

printf("%s\n", int(AeA));

INT_MAX和A都不会再被展开, 然而解决这个问题的方法很简单. 加多一层中间转换宏. 
加这层宏的用意是把所有宏的参数在这层里全部展开, 那么在转换宏里的那一个宏(_STR)就能得到正确的宏参数.  

#define A           (2) 
#define _STR(s)     #s 
#define STR(s)      _STR(s)          // 转换宏 
#define _CONS(a,b)  int(a##e##b) 
#define CONS(a,b)   _CONS(a,b)       // 转换宏 

printf("int max: %s\n", STR(INT_MAX));          // INT_MAX,int型的最大值,为一个变量 #include<climits>

输出为: int max: 0x7fffffff 
STR(INT_MAX) -->  _STR(0x7fffffff) 然后再转换成字符串;  

printf("%d\n", CONS(A, A));

输出为：200 
CONS(A, A)  -->  _CONS((2), (2))  --> int((2)e(2)) 

3)''#''和''##''的一些应用特例 
i) 合并匿名变量名  

#define  ___ANONYMOUS1(type, var, line)  type  var##line 
#define  __ANONYMOUS0(type, line)  ___ANONYMOUS1(type, _anonymous, line) 
#define  ANONYMOUS(type)  __ANONYMOUS0(type, __LINE__)

例：ANONYMOUS(static int);  即: static int _anonymous70;  70表示该行行号; 
第一层：ANONYMOUS(static int);  -->  __ANONYMOUS0(static int, __LINE__); 
第二层：                        -->  ___ANONYMOUS1(static int, _anonymous, 70); 
第三层：                        -->  static int  _anonymous70; 
即每次只能解开当前层的宏,所以__LINE__在第二层才能被解开; 

ii) 填充结构 
比如你要做一个菜单项命令名和函数指针组成的结构体的数组，并且希望在函数名和菜单项命令名之间有直观的、名字上的关系。那么下面的代码就非常实用： 

struct command
{
<span style="white-space:pre">	</span>char * name;
<span style="white-space:pre">	</span>void (*function) (void);
};
#define COMMAND(NAME) { NAME, NAME##_command }

然后你就用一些预先定义好的命令来方便的初始化一个command结构的数组了： 

struct command commands[] = {
COMMAND(quit),
COMMAND(help),
...
}

COMMAND宏在这里充当一个代码生成器的作用，这样可以在一定程度上减少代码密度，间接地也可以减少不留心所造成的错误。

再比如： 

#define  FILL(a)   {a, #a} 

enum IDD{OPEN, CLOSE}; 
typedef struct MSG{ 
<span style="white-space:pre">	</span>IDD id; 
<span style="white-space:pre">	</span>const char * msg; 
}MSG; 

MSG _msg[] = {FILL(OPEN), FILL(CLOSE)};

相当于： 

MSG _msg[] = {{OPEN, "OPEN"}, 
              {CLOSE, "CLOSE"}};

iii) 记录文件名 

#define  _GET_FILE_NAME(f)   #f 
#define  GET_FILE_NAME(f)    _GET_FILE_NAME(f) 
static char  FILE_NAME[] = GET_FILE_NAME(__FILE__);

iv) 得到一个数值类型所对应的字符串缓冲大小 
<pre name="code" class="cpp">#define  _TYPE_BUF_SIZE(type)  sizeof #type 
#define  TYPE_BUF_SIZE(type)   _TYPE_BUF_SIZE(type)

 

 

 

char  buf[TYPE_BUF_SIZE(INT_MAX)]; 
     -->  char  buf[_TYPE_BUF_SIZE(0x7fffffff)]; 
     -->  char  buf[sizeof "0x7fffffff"]; 

 

 
这里相当于： 

 

 

 

char  buf[11];
 

 
22. 关于...的使用 

 
...在C宏中称为Variadic Macro，也就是变参宏。比如： 

 

 

 
  
 
#define myprintf(templt,...) fprintf(stderr,templt,__VA_ARGS__)
 
 
 
 或者 
 
 

 

 
  
 
#define myprintf(templt,args...) fprintf(stderr,templt,args)
 
 
 
 
第一个宏中由于没有对变参起名，我们用默认的宏__VA_ARGS__来替代它。第二个宏中，我们显式地命名变参为args，那么我们在宏定义中就可以用 args来代指变参了。
同C语言的stdcall一样，变参必须作为参数表的最有一项出现。当上面的宏中我们只能提供第一个参数templt时，C标准要求我们必须写成：
 
 
 
 
myprintf(templt,);
 
 
 
 的形式。这时的替换过程为： 
 
 

 

 
  
 
myprintf("Error! ",);
 
 
 
 替换为： 
 
 

 

 
  
 
fprintf(stderr,"Error! ",);
 
 
 
 这是一个语法错误，不能正常编译。 
 
 
 这个问题一般有两个解决方法。首先，GNU CPP提供的解决方法允许上面的宏调用写成： 
 
 

 

 
  
 
myprintf(templt);
 
 
 
 而它将会被通过替换变成： 
 
 

 

 
  
 
fprintf(stderr,"Error! ",);
 
 
 
 很明显，这里仍然会产生编译错误(非本例的某些情况下不会产生编译错误)。 
 
 
 除了这种方式外，c99和GNU CPP都支持下面的宏定义方式： 
 
 

 

 
  
 
#define myprintf(templt, ...) fprintf(stderr,templt, ##__VAR_ARGS__)
 
 
 
 这时，##这个连接符号充当的作用就是当__VAR_ARGS__为空的时候，消除前面的那个逗号。那么此时的翻译过程如下： 
 
 

 

 
  
 
myprintf(templt);
 
 
 
 被转化为： 
 
 

 

 
  
 
fprintf(stderr,templt);
 
 
 
 这样如果templt合法，将不会产生编译错误。 
 
 
 
 
 23.错误的嵌套Misnesting 
 
 
 宏的定义不一定要有完整的、配对的括号，但是为了避免出错并且提高可读性，最好避免这样使用。 
 
 
 
 
 24.由操作符优先级引起的问题－Operator Precedence Problem 
 
 
 由于宏只是简单的替换，宏的参数如果是复合结构，那么通过替换之后可能由于各个参数之间的操作符优先级高于单个参数内部各部分之间相互作用的操作符优先级，如果我们不用括号保护各个宏参数，可能会产生预想不到的情形。 
 
 
 比如： 
 
 

 

 
  
 
#define ceil_div(x, y) (x + y - 1) / y
 
 
 
 那么 
 
 

 

 
  
 
a = ceil_div( b & c, sizeof(int) );
 
 
 
 将被转化为： 
 
 

 

 
  
 
a = ( b & c   + sizeof(int) - 1) / sizeof(int);
 
 
 
 由于+/-的优先级高于&的优先级，那么上面式子等同于： 
 
 

 

 
  
 
a = ( b & (c + sizeof(int) - 1)) / sizeof(int);
 
 
 
 这显然不是调用者的初衷。为了避免这种情况发生，应当多写几个括号： 
 
 

 

 
  
 
#define ceil_div(x, y) (((x) + (y) - 1) / (y))
 
 
 
 25.消除多余的分号－Semicolon Swallowing 
 
 
 通常情况下，为了使函数模样的宏在表面上看起来像一个通常的C语言调用一样，通常情况下我们在宏的后面加上一个分号，比如下面的带参宏： 
 
 

 

 
  
 
MY_MACRO(x);
 
 
 
 但是如果是下面的情况： 
 
 

 

 
  
 
#define MY_MACRO(x) {\
/* line 1 */\
/* line 2 */\
/* line 3 */ }

if (condition())
MY_MACRO(a);
else
{...}
 
 
 
 这样会由于多出的那个分号产生编译错误。为了避免这种情况出现同时保持MY_MACRO(x);的这种写法，我们需要把宏定义为这种形式： 
 
 

 

 
  
 
#define MY_MACRO(x) do {\
/* line 1 */\
/* line 2 */\
/* line 3 */ } while(0)
 
 
 
 这样只要保证总是使用分号，就不会有任何问题。 
 
 


                

        

        

    




    

      

        

            

              
                
                  CYKsky
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
c语言宏定义放置位置,c语言宏定义详解

				
			

			

				

					weixin_39552304的博客
				

				

					05-24
					
					1771
					
				

			

		

		

			
				
1,防止一个头文件被重复包含#ifndefCOMDEF_H#defineCOMDEF_H//头文件内容#endif2,重新定义一些类型,防止由于各种平台和编译器的不同,而产生的类型字节数 差异,方便移植。typedefunsignedcharboolean;/*Booleanvaluetype.*/typedefunsignedlong...

			
		

	



                

              
                



	

		

			

				
					
C语言宏定义用法大全

				
			

			

				

					06-11
				

			

		

		

			
				
关于C语言宏定义的用法，作了一个总结，除了常用宏定义外，还有类似函数的宏的用法

			
		

	



                


  
              

                


	

		

			

				
					
详解C语言中的宏定义

				
			

			

				

					sunlylorn的专栏
				

				

					01-19
					
					8581
					
				

			

		

		

			
				
1. 防止一个头文件被重复包含 
#ifndef COMDEF_H 
#define COMDEF_H 
//头文件内容 
#endif 



2. 重新定义一些类型,防止由于各种平台和编译器的不同,而产生的类型字节数差异,方便移植。 
typedef  unsigned char      boolean;     /* Boolean value type. */ 
typede

			
		

	





	

		

			

				
					
什么是 C 语言中的宏定义？

					
最新发布

				
			

			

				

					技术笔记
				

				

					07-10
					
					744
					
				

			

		

		

			
				
在 C 语言中，宏定义是一种预处理指令，用于将一个标识符定义为一个特定的文本序列（称为宏体）。在程序编译之前，预处理器会将程序中出现的宏标识符替换为对应的宏体。提高代码的可读性和可维护性，通过给复杂的表达式或常用的常量赋予有意义的名称。方便代码的修改，如果需要更改某个常量或表达式，只需修改宏定义一处即可。C 语言中的宏定义主要分为两种类型：对象宏（也称为变量宏）和函数宏。对象宏对象宏用于定义常量或简单的表达式。其定义的一般形式为：# define 标识符 替换文本#define PI。

			
		

	



		

			
		



	

		

			

				
					
宏有什么作用c语言,C语言中的宏定义有什么用？

				
			

			

				

					weixin_42355311的博客
				

				

					05-16
					
					1395
					
				

			

		

		

			
				
满意答案bushuohuaz52推荐于 2017.11.26您好！很高兴为您解答。宏定义的用处主要体现在便于程序的调试上。比如我要写一个计算圆相关信息(周长、面积等等)的程序，需要定义π(3.14)：#define PI 3.14那么势必PI这个标识可以在程序中代替所有的3.14，如果我发现计算的精度不够，需要π的更多有效位时，则只需将宏定义修改为：#define PI 3.1415926那么程序...

			
		

	





	

		

			

				
					
c语言中宏定义作用,C语言中宏定义的用法与意义

				
			

			

				

					weixin_35541666的博客
				

				

					05-16
					
					1215
					
				

			

		

		

			
				
《C语言中宏定义的用法与意义》由会员分享，可在线阅读，更多相关《C语言中宏定义的用法与意义(6页珍藏版)》请在人人文库网上搜索。1、C语言中宏定义的用法与意义C语言宏定义技巧(常用宏定义)写好C语言，漂亮的宏定义很重要，使用宏定义可以防止出错，提高可移植性，可读性，方便性等等。下面列举一些成熟软件中常用得宏定义。1，防止一个头文件被重复包含#ifndef COMDEF_H#define COMDE...

			
		

	





	

		

			

				
					
C语言学习之宏定义用法——并不只是用来提高可读性

				
			

			

				

					u013511885的博客
				

				

					10-14
					
					587
					
				

			

		

		

			
				
(一)用法

普通替换
宏函数
用法和普通函数一样，只不过在预处理阶段，宏函数会被展开，没有普通函数保存寄存器和参数传递的开销。#define min(X, Y)  ((X) < (Y) ? (X) : (Y))
y = min(1, 2);//会被扩展成y = ((1) < (2) ? (1) : (2));



(二)宏操作符


# 它可以把宏的参数转换成字符串字面值（相当于给...

			
		

	





	

		

			

				
					
c语言宏定义详解

				
			

			

				

					04-10
				

			

		

		

			
				
宏定义在C语言中是预处理器指令的一种，它允许对...以上就是一些常用的C语言宏定义及其用法说明，这些宏定义能够帮助编写更加健壮和可维护的代码。在实际编程工作中，应该根据具体的编程规范和需求来选择合适的宏定义。

			
		

	





	

		

			

				
					
详解C语言中的#define宏定义命令用法

				
			

			

				

					12-25
				

			

		

		

			
				
在源程序中每次遇到该标识符时，均以定义的串代换它。ANSI标准将标识符定义为宏名，将替换过程称为宏替换。命令的一般形式为：   #define identifier string  注意： 1.该语句没有分号。在标识符和串之间可以有任意...

			
		

	





	

		

			

				
					
基于C中含有if的宏定义详解

				
			

			

				

					01-20
				

			

		

		

			
				
含有if的宏定义当宏定义中含有 if 时1) 定义如下宏#define DC(p) if( foo(p) )fun(p)用在下面的环境中if(k>n)DC(k);elseDC(n);宏替换后,如下if(k>n)if( foo(k) )fun(k);elseif( foo(n) )fun( n );可见, 原来的 if 和...

			
		

	





	

		

			

				
					
C语言：宏定义的妙用

				
			

			

				

					I_feige的博客
				

				

					08-07
					
					404
					
				

			

		

		

			
				
C语言：宏定义的妙用
一、定义别名标识符
二、连接符“\”
三、宏函数
四、字符连接与串化
五、@# 字符化操作符

			
		

	





	

		

			

				
					
C语言宏定义作用、使用方法小结(2)

				
			

			

				

					zhao67865的专栏
				

				

					10-10
					
					2167
					
				

			

		

		

			
				
要写好C语言，漂亮的宏定义是非常重要的。宏定义可以帮助我们防止出错，提高代码的可移植性和可读性等。

　　在软件开发过程中，经常有一些常用或者通用的功能或者代码段，这些功能既可以写成函数，也可以封装成为宏定义。那么究竟是用函数好，还是宏定义好？这就要求我们对二者进行合理的取舍。

　　我们来看一个例子，比较两个数或者表达式大小，首先我们把它写成宏定义：

　　#define MAX(

			
		

	





	

		

			

				
					
C语言宏的主要作用

				
			

			

				

					weixin_47898310的博客
				

				

					05-15
					
					2878
					
				

			

		

		

			
				
宏主要有四大类作用：
1.和条件编译指令配合，进行条件编译.
比如: 1)头文件的防止多重包含机制.
	  2)根据不同编译器选择不同代码段.

2.对需要变动的常量进行控制.
	比如: 控制定义数组的长度.

3.对应码(比如寄存器功能码、状态码、指令的参数码、一些协议的指令码)
	1)降低使用具体码的出错率.(有语义的标识符出错时编译器会报错)
	2)降低开发时开发人员的记忆量.(即有语义的标识符比记杂乱的数字容易)

	在这种情况下，宏定义就是将被宏定义的东西和特定宏标识符对应起来，让人只要在意它所对

			
		

	





	

		

			

				
					
C中几个特定宏的介绍(一些调试的小技巧)

				
			

			

				

					Walker—fire的博客
				

				

					08-27
					
					538
					
				

			

		

		

			
				
C中的宏__FUNCTION__、__TIME__、__LINE__等(一些调试的小技巧)

			
		

	





	

		

			

				
					
玩转宏定义——从入门到进阶

				
			

			

				

					m0_49806738的博客
				

				

					03-22
					
					2729
					
				

			

		

		

			
				
宏定义是 C/C++ 中的一种预处理指令，但是在日常编程中我们总觉得用不上，用不好。本文由浅入深的以宏定义在编程中的各类作用为导向，给大家带来一篇不一样的宏定义思考路线。

			
		

	





	

		

			

				
					
【C语言基础】宏定义的用法详解

				
			

			

				

					欢迎时常光顾我的干货超市，热衷于AIoT！！
				

				

					08-19
					
					4728
					
				

			

		

		

			
				
本篇总结并较为详细地阐述了宏定义的多种用法，

			
		

	





	

		

			

				
					
C语言当中的宏定义，宏的相关概念和作用和用法

				
			

			

				

					程序员猫爪
				

				

					02-26
					
					5717
					
				

			

		

		

			
				
一、什么是宏
1、用一个字符串表示有意义的常量或常量表达式（被称为宏）
二、如何来定义宏
1、宏的分类：
A、有参宏：
格式：
		#define  宏名  常量或常量表达式
比如：
		#define  PI  3.14  (以后在程序当中只要看到了PI就代表3.14)

#include<stdio.h> 
#define PI 3.14
void main(){
	int r =...

			
		

	





	

		

			

				
					
#define用法

				
			

			

				

					yiyele的博客
				

				

					10-22
					
					7849
					
				

			

		

		

			
				
1.简单的宏定义#  define 标识符 替换列表（替换列表可以是数，字符串字面量，标点符号，运算符，标识符，关键字，字符常量。注意：替换列表是可以为空的） 
典型错误： 
 #define N = 100 
int a[N]; /这样会成为int a[= 100],这里会处理成为一种标识记号一样/#define N 100; 
int a[N]; /带分号的定义会成为int a[100;],这是

			
		

	





	

		

			

				
					
C语言宏定义详解

					
热门推荐

				
			

			

				

					qq_28576837的博客
				

				

					06-01
					
					2万+
					
				

			

		

		

			
				
C语言宏定义详解

			
		

	





	

		

			

				
					
C语言宏定义详解：用法与示例

				
			

			

				

					
				

			

		

		

			
				
"本文主要介绍了C语言中的宏定义及其用法，包括无参数宏定义、带参数宏定义以及宏定义的一些注意事项。通过实例解析了宏如何替代常量、全局变量、数组元素和表达式，并讨论了宏定义的作用域和取消定义的方法。"  在...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值