精华内容
下载资源
问答
  • C语言宏定义 参考连接: https://blog.csdn.net/u013910522/article/details/22672057 https://www.cnblogs.com/bytebee/p/8205707.html 宏定义的优点: 1. 便于代码的移植和可读 例如:使用宏定义替一个在...
                                                  C语言宏定义  
    
    参考连接:
    https://blog.csdn.net/u013910522/article/details/22672057
    https://www.cnblogs.com/bytebee/p/8205707.html
    
    宏定义的优点:
        
        1. 便于代码的移植和可读        
        例如:使用宏定义替一个在程序中经常使用的常量或变量类型,便于全局修改和使用;
        
        2. 提高程序运行效率
        函数调用会带来额外的开销,它需要开辟一片栈空间,记录返回地址,将形参压栈,从函数返回还要释放堆栈。
        
    
    宏定义的缺点:
        
        1. 无法对宏定义中的变量类型是否匹配进行检查
        宏定义变量,是Compile-Time时期的变量,系统在编译时候,就将其全部替换,而不会对其变量进行类型检查,相对不是很安全,可能存在潜在的问题,而没有发现.
    
        2. 未加括号带来的边界效应
        由于宏定义的时候,其各个分量未加括号,而在使用宏定义的时候,传递的参数是变量的表达式,然后经过系统展开后,由于优先级的原因,导致其结果不是用户所希望的。
        
        [例子] 传递参数是变量的表达式
    
        #define MUL(A,B) A*B
    
        而在使用的时候,这样的调用:
    
        int a=1,b=2,c=3,d=0;
    
        d=MUL(a+b,c)
    
        经过编译时候展开,就变成了
    
        d=a+b*c
    
        而不是我们所希望的
    
        d=(a+b)*c
    
        [解决办法]
    
        其解决办法也很简单,就是给每个分量,都加上括号,就可以避免此类问题
    
        即,在宏定义的时候,如此定义:
    
        #define MUL(A,B) ((A)*(B))
        
        
        [例子] 在define数据类型的时候, 未加括号带来的问题
    
        #define dPS struct s *   //注意末尾无分号
    
        当使用的时候,遇到:
    
        dPS p1,p2;
    
        的时候,经过编译时候替换扩展,就变成了
    
        struct s* p1,p2;
    
        而p2就不是我们所希望的s的指针类型了,而是一个普通的s数据结构类型的了.产生了边界效应.
    
        [解决办法]
    
        对应的解决办法也很简单,就是,遇到此类新数据类型定义的时候,还是用typedef
    
        将上述宏定义改为:
    
        typedef struct s * tPS; // 注意末尾有分号
    
        而后的使用:
    
        tPS p1,p2;
    
        就正常了.
        
        
        ///    
        函数宏定义
        
        用途1:简单函数可以用宏定义代替,以便于代码可读性与运行效率
        隐含的优点为:函数的参数必须被声明为一种特定的类型,所以它只能在类型合适的表达式上使用,我们如果要比较两个浮点型的大小,就不得不再写一个专门针对浮点型的比较函数。而宏定义则可以使用任何类型的变量。
        
        [例子] 求2个变量最大值的函数
        宏定义实现: #define MAX( a, b) ( (a) > (b) (a) : (b) )
        
       函数来实现:
       int max( int a, int b)
       {
           return (a > b a : b)
       }
        
        
        用途2:传递带参数类型的宏
        解释:参数类型没法作为形参一部分传递给函数,但是可以把参数类型传递给带参的宏。
        
        [例子] 传递参数类型的函数宏定义
        #define MALLOC(n, type) \
      ( (type *) malloc((n)* sizeof(type)))
    
      利用这个宏,就可以为任何类型变量分配一段我们指定的空间大小,并返回指向这段空间的指针。
        宏确切的工作过程:
      int *ptr;
      ptr = MALLOC ( 5, int );
      将这宏展开以后的结果:
      ptr = (int *) malloc ( (5) * sizeof(int) );
      这个例子是宏定义的经典应用之一,完成了函数不能完成的功能。
    
    展开全文
  • 尽管函数宏定义和普通函数相比有很多缺点,但只要小心使用还是会显著提高代码的执行效率,毕竟省去了分配和释放栈帧、传参、传返回值等一系列工作,因此那些简短并且被频繁调用的函数经常用函数宏定义来代替实现...

    http://www.jb51.net/article/41869.htm

    尽管函数式宏定义和普通函数相比有很多缺点,但只要小心使用还是会显著提高代码的执行效率,毕竟省去了分配和释放栈帧、传参、传返回值等一系列工作,因此那些简短并且被频繁调用的函数经常用函数式宏定义来代替实现

    在C及C++语言中允许用一个标识符来表示一个字符串,称为宏,该字符串可以是常数、表达式、格式串等。在编译预处理时,对程序中所有出现的“宏名”,都用宏定义中的字符串去代换,这称为“宏代换”或“宏展开”。宏定义是由源程序中的宏定义命令完成的。宏代换是由预处理程序自动完成的。若字符串是表达式,我们称之为函数式宏定义,那函数式宏定义与普通函数有什么区别呢?

    我们以下面两行代码为例,展开描述:
    函数式宏定义:#define MAX(a,b) ((a)>(b)?(a):(b))
    普通函数 :MAX(a,b) { return a>b?a:b;}

    (1)函数式宏定义的参数没有类型,预处理器只负责做形式上的替换,而不做参数类型检查,所以传参时要格外小心。

    (2)调用真正函数的代码和调用函数式宏定义的代码编译生成的指令不同。

    如果MAX是个普通函数,那么它的函数体return a > b ? a : b; 要编译生成指令,代码中出现的每次调用也要编译生成传参指令和call指令。而如果MAX是个函数式宏定义,这个宏定义本身倒不必编译生成指令,但是代码中出现的每次调用编译生成的指令都相当于一个函数体,而不是简单的几条传参指令和call指令。所以,使用函数式宏定义编译生成的目标文件会比较大。

    (3)函数式宏定义要注意格式,尤其是括号。

    如果上面的函数式宏定义写成 #define MAX(a, b) (a>b?a:b),省去内层括号,则宏展开就成了k = (i&0x0f>j&0x0f?i&0x0f:j&0x0f),运算的优先级就错了。同样道理,这个宏定义的外层括号也是不能省的。若函数中是宏替换为 ++MAX(a,b),则宏展开就成了 ++(a)>(b)?(a):(b),运算优先级也是错了。

    (4)若函数参数为表达式,则普通函数的调用与函数式宏定义的替换过程是不一样的。

    普通函数调用时先求实参表达式的值再传给形参,如果实参表达式有Side Effect,那么这些SideEffect只发生一次。例如MAX(++a, ++b),如果MAX是普通函数,a和b只增加一次。但如果MAX函数式宏定义,则要展开成k = ((++a)>(++b)?(++a):(++b)),a和b就不一定是增加一次还是两次了。所以若参数是表达式,替换函数式宏定义时一定要仔细看好。

    (5)函数式宏定义往往会导致较低的代码执行效率。

    看下面一段代码:

    复制代码 代码如下:

    int a[]={9,3,5,2,1,0,8,7,6,4};
    int max(n)
    {
        return n==0?a[0]:MAX(a[n],max(n-1));
    }

    int main()
    {
        max(9);
        return 0;
    }


    若是普通函数,则通过递归,可取的最大值,时间复杂度为O(n)。但若是函数式宏定义,则宏展开为( a[n]>max(n-1)?a[n]:max(n-1) ),其中max(n-1)被调用了两遍,这样依此递归下去,时间复杂度会很高。

    尽管函数式宏定义和普通函数相比有很多缺点,但只要小心使用还是会显著提高代码的执行效率,毕竟省去了分配和释放栈帧、传参、传返回值等一系列工作,因此那些简短并且被频繁调用的函数经常用函数式宏定义来代替实现。


    http://blog.sina.com.cn/s/blog_861912cd0100tc94.html

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

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

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

      #define MAX( a, b) ( (a) > (b) (a) : (b) )

      其次,把它用函数来实现:

      int max( int a, int b)

      {

      return (a > b a : b)

      }

      很显然,我们不会选择用函数来完成这个任务,原因有两个:首先,函数调用会带来额外的开销,它需要开辟一片栈空间,记录返回地址,将形参压栈,从函数返回还要释放堆栈。这种开销不仅会降低代码效率,而且代码量也会大大增加,而使用宏定义则在代码规模和速度方面都比函数更胜一筹;其次,函数的参数必须被声明为一种特定的类型,所以它只能在类型合适的表达式上使用,我们如果要比较两个浮点型的大小,就不得不再写一个专门针对浮点型的比较函数。反之,上面的那个宏定义可以用于整形、长整形、单浮点型、双浮点型以及其他任何可以用“>”操作符比较值大小的类型,也就是说,宏是与类型无关的。

      和使用函数相比,使用宏的不利之处在于每次使用宏时,一份宏定义代码的拷贝都会插入到程序中。除非宏非常短,否则使用宏会大幅度增加程序的长度。

      还有一些任务根本无法用函数实现,但是用宏定义却很好实现。比如参数类型没法作为参数传递给函数,但是可以把参数类型传递给带参的宏。

      看下面的例子:

      #define MALLOC(n, type) \

      ( (type *) malloc((n)* sizeof(type)))

      利用这个宏,我们就可以为任何类型分配一段我们指定的空间大小,并返回指向这段空间的指针。我们可以观察一下这个宏确切的工作过程:

      int *ptr;

      ptr = MALLOC ( 5, int );

      将这宏展开以后的结果:

      ptr = (int *) malloc ( (5) * sizeof(int) );

      这个例子是宏定义的经典应用之一,完成了函数不能完成的功能,但是宏定义也不能滥用,通常,如果相同的代码需要出现在程序的几个地方,更好的方法是把它实现为一个函数。

      下面总结和宏和函数的不同之处,以供大家写代码时使用,这段总结摘自《C和指针》一书。


     


    example:

    define的单行定义

    #define maxi(a,b) (a>;b?a:b)
    define的多行定义

    define可以替代多行的代码,例如MFC中的宏定义(非常的经典,虽然让人看了恶心)

    #define     MACRO(arg1,     arg2)     do     {     \
         \
    stmt1;     \
    stmt2;     \
         \
       while(0)   
    关键是要在每一个换行的时候加上一个 "\ "


    //宏定义写出swap(x,y)交换函数
    #define swap(x, y)\
    x = x + y;\
    y = x - y;\
    x = x - y;


    zigbee里多行define有如下例子

    #define FillAndSendTxOptions( TRANSSEQ, ADDR, ID, LEN, TxO ) { \
    afStatus_t stat;                                                                       \
    ZDP_TxOptions = (TxO);                                                           \
    stat = fillAndSend( (TRANSSEQ), (ADDR), (ID), (LEN) );                   \
    ZDP_TxOptions = AF_TX_OPTIONS_NONE;                                 \
    return stat;                                                                               \
    }

    展开全文
  •  在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。  首先,宏定义实现:  #define MAX( a, b) ( (a) > (b) ?(a) : (b) )  其...

           宏定义可以帮助我们防止出错,提高代码的可移植性和可读性等。

           在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。

           首先宏定义实现

                                    #define MAX( a, b) ( (a) > (b) (a) : (b) )

      其次,函数实现:

                   int max( int a, int b)

                   {

                                    return (a > b a : b)

                    }

      很显然,我们不会选择用函数来完成这个任务,原因有两个:首先,函数调用会带来额外的开销,它需要开辟一片栈空间,记录返回地址,将形参压栈,从函数返回还要释放堆栈。这种开销不仅会降低代码效率,而且代码量也会大大增加,而使用宏定义则在代码规模和速度方面都比函数更胜一筹;其次,函数的参数必须被声明为一种特定的类型,所以它只能在类型合适的表达式上使用,我们如果要比较两个浮点型的大小,就不得不再写一个专门针对浮点型的比较函数。反之,上面的那个宏定义可以用于整形、长整形、单浮点型、双浮点型以及其他任何可以用“>”操作符比较值大小的类型,也就是说,宏是与类型无关的。

      和使用函数相比,使用宏的不利之处在于每次使用宏时,一份宏定义代码的拷贝都会插入到程序中。除非宏非常短,否则使用宏会大幅度增加程序的长度。

      还有一些任务根本无法用函数实现,但是用宏定义却很好实现。比如参数类型没法作为参数传递给函数,但是可以把参数类型传递给带参的宏。

      看下面的例子:

    #define MALLOC(n, type) \

      ( (type *) malloc((n)* sizeof(type)))

      利用这个宏,我们就可以为任何类型分配一段我们指定的空间大小,并返回指向这段空间的指针。我们可以观察一下这个宏确切的工作过程:

    int *ptr;

    ptr = MALLOC ( 5, int );

      将这宏展开以后的结果:

    ptr = (int *) malloc ( (5) * sizeof(int) );

      这个例子是宏定义的经典应用之一,完成了函数不能完成的功能,但是宏定义也不能滥用,通常,如果相同的代码需要出现在程序的几个地方,更好的方法是把它实现为一个函数。

     

    展开全文
  • 宏定义函数重载

    2019-06-24 18:21:53
    在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么究竟是用函数好,还是宏定义好?这就要求我们对二者进行合理的取舍。 宏定义中允许包含两行以上...

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

    宏定义中允许包含两行以上命令的情形,此时必须在最右边加上”\”且该行”\”后不能再有任何字符,连注释部分都不能有,下面的每行最后的一定要是”\”,”\”后面加一个空格都会报错,更不能跟注释。

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

    #define MAX( a, b) ( (a) > (b) (a) : (b) )

    其次,把它用函数来实现:

    int max( int a, int b)

    {

    return (a > b a : b)

    }

    很显然,我们不会选择用函数来完成这个任务,原因有两个:首先,函数调用会带来额外的开销,它需要开辟一片栈空间,记录返回地址,将形参压栈,从函数返回还要释放堆栈。这种开销不仅会降低代码效率,而且代码量也会大大增加,而使用宏定义则在代码规模和速度方面都比函数更胜一筹;其次,函数的参数必须被声明为一种特定的类型,所以它只能在类型合适的表达式上使用,我们如果要比较两个浮点型的大小,就不得不再写一个专门针对浮点型的比较函数。反之,上面的那个宏定义可以用于整形、长整形、单浮点型、双浮点型以及其他任何可以用“>”操作符比较值大小的类型,也就是说,宏是与类型无关的。

    和使用函数相比,使用宏的不利之处在于每次使用宏时,一份宏定义代码的拷贝都会插入到程序中。除非宏非常短,否则使用宏会大幅度增加程序的长度。

    还有一些任务根本无法用函数实现,但是用宏定义却很好实现。比如参数类型没法作为参数传递给函数,但是可以把参数类型传递给带参的宏。

    看下面的例子:

    #define MALLOC(n, type)
      ( (type ) malloc((n) sizeof(type)))
    1
    2
      利用这个宏,我们就可以为任何类型分配一段我们指定的空间大小,并返回指向这段空间的指针。我们可以观察一下这个宏确切的工作过程:

    int *ptr;
    ptr = MALLOC ( 5, int );
      将这宏展开以后的结果:

    ptr = (int ) malloc ( (5) sizeof(int) );
      这个例子是宏定义的经典应用之一,完成了函数不能完成的功能,但是宏定义也不能滥用,通常,如果相同的代码需要出现在程序的几个地方,更好的方法是把它实现为一个函数。

    下面总结和宏和函数的不同之处,以供大家写代码时使用,这段总结摘自《C和指针》一书。

    【转】C语言中DEFINE简介及多行宏定义

    EXample

    define的单行定义

    #define maxi(a,b) (a>;b?a:b)
    define的多行定义

    define可以替代多行的代码,例如MFC中的宏定义(非常的经典,虽然让人看了恶心)

    #define MACRO(arg1, arg2) do { \
    \
    stmt1; \
    stmt2; \
    \
    } while(0)
    1
    2
    3
    4
    5
    6
    关键是要在每一个换行的时候加上一个 “\ “

    //宏定义写出swap(x,y)交换函数
    /#define swap(x, y)
    x = x + y;
    y = x - y;
    x = x - y;
    1
    2
    3
    4
    5
    自己写的一个小例子:

    // 不能加 *
    应为 指针
    也是一种类型
    #define SORT( a, n)
    {
    int i, j;
    int t = MALLOC(1,int);
    for(i=0; i<n-1; i++)
    {
    for(j=0; j<n-1-i; j++)
    {
    if(
    (a+j) > *(a+j+1))
    {
    *t = *(a+j);
    *(a+j) = *(a+j+1);
    *(a+j+1) = *t;
    }
    }
    }
    }
    int main(int argc,
    const char * argv[])
    {
    int a=10, b=
    120;
    int data[]={3,200,5};
    //swap(&a, &b);

    // sort(data, 3); //和队列一样:会依据专题的(shi can)参数
    自动识别类型

    SORT(data, 3);     
    

    //会主动用实参
    代替
    形参
    识别类型

    for(int i=0;i<3;i++)
    cout << data[i]  << endl;
    
    
    //printf("%d   %d", a, b);
    return 0;
    

    }
    学过c++语言都知道函数重载,宏可以重载吗?

    #define MACRO(number) TL_ADD(number,10)
    #define MACRO(number1,number2) TL_ADD(number1,number2)
    上面定义了两个同名的宏MACRO,如果有两个参数,就返回两个参数的和,如果是一个参数,就把这个参数加上10返回。
    但是c的宏处理器是不允许定义两个同名的宏,编译的时候就会报错。

    我们可以通过变参数宏的一些特性来达到根据不同参数调用不同宏的目的。

    展开全文
  • 为什么在C语言中要有函数宏定义这种形式呢?宏定义可以帮助我们防止出错,提高代码的可移植性和可读性等。  在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为...
  •  在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么究竟是用函数好,还是宏定义好?这就要求我们对二者进行合理的取舍。  我们来看一个例子,...
  • C语言宏定义和宏函数

    2015-11-18 21:34:59
     在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么究竟是用函数好,还是宏定义好?这就要求我们对二者进行合理的取舍。  我们来看一个例子,比较...
  • 在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么究竟是用函数好,还是宏定义好?这就要求我们对二者进行合理的取舍。 我们来看一个例子,比较两...
  • c语言宏定义和宏函数

    2014-08-11 09:49:29
     在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么究竟是用函数好,还是宏定义好?这就要求我们对二者进行合理的取舍。  我们来看一个例子,...
  • 宏定义函数VS普通函数VS内联函数 宏定义函数VS普通函数 宏定义函数 要点:变量都用括号括起来,防止出错,结尾不需要;。在实际编程中,不推荐把复杂的函数使用宏,不容易调试。多行用\ 例子: 单行: #define ...
  • 代码片段如何作为宏定义函数参数

    千次阅读 2017-09-01 21:08:37
    #include #define FH(code) code #define F(code) FH code int main(void){ F(( int a; int b; char *s="HELLO"; printf("%s\n",s); )); }
  • 宏定义函数

    2017-01-06 23:15:47
     在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么究竟是用函数好,还是宏定义好?这就要求我们对二者进行合理的取舍。  我们来看一个例子,比较...
  • 宏定义中的参数称为形式参数,在宏调用中的参数称为实际 参数。 对带参数的宏,在调用中,不仅要宏展开,而且要用实参去代换形参。 带参宏定义的一般形式为: #define 宏名(形参列表) 字符串 在字符串中含有各个...
  • C语言宏定义函数

    2018-11-08 19:07:16
    C语言宏定义宏定义函数   宏定义可以帮助我们防止出错,提高代码的可移植性和可读性等。  在软件开发过程中,经常有一些常用或者通用的功能或者代码段,这些功能既可以写成函数,也可以封装成为宏定义。那么...
  • C语言中的宏定义与宏函数定义entry1 参考: http://blog.sina.com.cn/s/blog_861912cd0100tc94.html 关键词:宏定义; 宏函数定义; 引言: 要写好C语言,漂亮的宏定义是非常重要的。宏定义可以帮助我们防止出错...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,366
精华内容 6,146
关键字:

宏定义作为函数形参