精华内容
下载资源
问答
  • C语言不带参数定义

    千次阅读 2019-01-22 21:51:09
     不带参数定义一般格式如下: #define 宏名 字符串 1> “#”表示这是一条预处理命令 2>“宏名”是一个标识符,必须符合C语言标识符的规定 3>“字符串”在此可以...

       宏定义命令 #define 用来定义一个标识符和一个字符串,以这个标识符来代表这个字符串,在程序

    中每次遇到该标识符时就用所定义的字符串替换它,其作用相当于给置顶的字符串起一个别名。

      不带参数的宏定义一般格式如下:

    #define 宏名 字符串

    1> “#”表示这是一条预处理命令

    2>“宏名”是一个标识符,必须符合C语言标识符的规定

    3>“字符串”在此可以是常数、表达式、格式字符串等

    例如:

    #define PI 3.14159

    其作用是在该程序中用PI替代3.14159,在编译预处理时,每当在源程序中遇到PI就自动用3.14159

    代替。

      使用#define进行宏定义的好处是需要改变一个常量的时候只需要改变#define命令行,整个程序的常

    量都会改变,大大提高了程序的灵活性。

      宏名要简单且意义明确,一般习惯用大写字母表示,以便与变量名相区别。

      注意:宏定义不是C语句,不需要在行末加分号。

      宏名定义后,即可成为其他宏名定义中的一部分。例如,下面代码定义了正方形的边长SIDE、周

    长PERIMETER及面积AREA的值。

    #define SIDE 5
    #define PERIMETER 4*SIDE
    #define AREA SIDE*SIDE
    

      前面强调过宏替换是以串代替标识符,这一点要牢记。因此,如果希望定义一个标准的邀请语,

    可编写如下代码。

     

    #define STANDARD "You are welcome to join us."
    printf(STANDARD);

    编译程序遇到标识符STANDARD时,就会用"You are welcome to join us."替换。

    对于编译程序,printf()语句如下形式是等效的。

    printf("You are welcome to join us.");

    对于不带参数的宏定义有以下几点要强调一下:

    1、如果在串中含有宏名,则不进行替换。

      例如:

    #include <stdio.h>
    
    #define TEST "this is an example"
    
    int main(void) { 
          
          char exp[30] = "This TEST is not that TEST";
           
           printf("%s\n", exp);
            
        
    
    	return 0;
    }

    该段代码的输入结果如下:

    This TEST is not that TEST

    注意上面程序字符串中的TEST并没有用"this is an example"来替换,所以说如果串中含有宏名,

    则不进行替换。

    2、如果串长于一行,可以在该行末尾用一反斜杠“\”续行。

    3、#define 命令出现在程序中函数的外面,宏名的有效范围为定义命令之后到此源文件结束。

    注意:在编写程序时通常将所有的#define放到文件的开始处或独立的文件中,而不是将它们分散到

    整个程序中。

    4、可以用#undef命令终止宏定义的作用域。

    例如以下程序

    #include <stdio.h>
    
    #define TEST "this is an example"
    
    int main(void) { 
          
           
           printf(TEST);
           
    
    	return 0;
    }

    程序输出为:

    this is an example

    修改程序为:

    #include <stdio.h>
    
    #define TEST "this is an example"
    
    int main(void) { 
          
          
           
           printf(TEST);
           #undef TEST
           
           printf(TEST);
            
        
    
    	return 0;
    }

    使用#undef,然后再打印 TEST,会报错

    Compilation Failed
    
    
    /usercode/file.cpp: In function ‘int main()’:
    /usercode/file.cpp:12:15: error: ‘TEST’ was not declared in this scope
            printf(TEST);

    显示TEST未定义。

    展开全文
  • 宏定义有无参数宏定义和带参数宏定义两种。  无参数的宏定义的一般形式为  # define 标识符 字符序列 其中# define之后的标识符称为宏定义名(简称宏名),要求宏名与字符序列之间用空格符分隔。这种宏定义要求...
    宏定义有无参数宏定义带参数宏定义两种。
       无参数的宏定义的一般形式为
                # define 标识符 字符序列

    其中# define之后的标识符称为宏定义名(简称宏名),要求宏名与字符序列之间用空格符分隔。这种宏定义要求编译预处理程序将源程序中随后所有的定名的出现(注释与字符串常量中的除外)均用字符序列替换之。前面经常使用的定义符号常量是宏定义的最简单应用。如有:
                # define TRUE 1
                # define FALSE 0
    则在定义它们的源程序文件中,凡定义之后出现的单词TRUE将用1替代之;出现单词FALSE将用0替代之。
           在宏定义的#之前可以有若干个空格、制表符,但不允许有其它字符。宏定义在源程序中单独另起一行,换行符是宏定义的结束标志。如果一个宏定义太长,一行不 够时,可采用续行的方法。续行是在键人回车符之前先键入符号"/"。注意回车要紧接在符号"/"之后,中间不能插入其它符号。
          宏定义的有效范围称为宏定义名的辖域,辖域从宏定义的定义结束处开始到其所在的源程序文件末尾。宏定义名的辖域不受分程序结构的影响。可以用预处理命令#undef终止宏定义名的辖域。
      在新的宏定义中,可以使用前面已定义的宏名。例如,
                 # define R 2.5
                 # define PI 3.1415926
                 # define Circle 2*PI*R
                 # define Area PI* R * R
    程序中的Circle被展开为2*3.1415926* 2.5, Area被展开为3.1415926*2.5*2.5。
         如有必要,宏名可被重复定义。被重复定义后,宏名原先的意义被新意义所代替。

         通常,无参数的宏定义多用于定义常量。程序中统一用宏名表示常量值,便于程序前后统一,不易出错,也便于修改,能提高程序的可读性和可移植性。特别是给数组元素个数一个宏定义,并用宏名定义数组元素个数能部分弥补数组元素个数固定的不足。
          注意:预处理程序在处理宏定义时,只作字符序列的替换工作,不作任何语法的检查。如果宏定义不当,错误要到预处理之后的编译阶段才能发现。宏定义以换行结束,不需要分号等符号作分隔符。如有以下定定义:
       # define PI 3.1415926;
    原希望用PI求圆的周长的语句
       c=2*PI*r;
    经宏展开后,变成
       c=2*3.1415926*r;
    这就不能达到希望的要求。
       带参数宏定义进一步扩充了无参数宏定义的能力,在字符序列替换同时还能进行参数替换。带参数定定义的一般形式为
       # define 标识符(参数表)字符序列
    其中参数表中的参数之间用逗号分隔,字符序列中应包含参数表中的参数。
    在定义带参数的宏时,宏名标识符与左圆括号之间不允许有空白符,应紧接在一起,否则变成了无参数的宏定义。如有宏定义:
       # define MAX(A,B) ((A) > (B)?(A):(B))

    则代码 y= MAX( p+q, u+v)将被替换成 y=((p+q) >(u+v)?(p+q):(u+v)。
               程序中的宏调用是这样被替换展开的,分别用宏调用中的实在参数字符序列(如p+q和u+V) 替换宏定义字符序列中对应所有出现的形式参数(如用p+q替代所有形式参数A,用u+V替代所有形式参数B),而宏定义字符序列中的不是形式参数的其它字 符则保留。这样形成的字符序列,即为宏调用的展开替换结果。宏调用提供的实在参数个数必须与宏定义中的形式参数个数相同。
           注意:宏调用与函数调用的区别。函数调用在程序运行时实行,而宏展开是在编译的预处理阶段进行;函数调用占用程序运行时间,宏调用只占编译时间;函数调用 对实参有类型要求,而宏调用实在参数与宏定义形式参数之间没有类型的概念,只有字符序列的对应关系。函数调用可返回一个值,宏调用获得希望的C代码。另 外,函数调用时,实参表达式分别独立求值在前,执行函数体在后。宏调用是实在参数字符序列替换形式参数。替换后,实在参数字符序列就与相邻的字符自然连 接,实在参数的独立性就不一定依旧存在。如下面的宏定义:
       # define SQR(x) x*x
    希望实现表达式的平方计算。对于宏调用
       P=SQR(y)
    能得到希望的宏展开p= y*y。但对于宏调用q=SQR(u+v)得到的宏展开是q=u+V*u+V。显然,后者的展开结果不是程序设计者所希望的。为能保持实在参数替换后的独立性,应在宏定义中给形式参数加上括号。进一步,为了保证宏调用的独立性,作为算式的宏定义也应加括
    号。如 SQR宏定义改写成:
       # define SQR((x)*(x))
    才是正确的宏定义。

          对于简短的表达式计算函数,或为了提高程序的执行效率、避免函数调用时的分配存储单元、保留现场、参数值传递、释放存储单元等工作。可将函数定义改写成宏定义。所以合理使用宏定义,可以使程序更简洁。


    使用一些宏跟踪调试

    A N S I标准说明了五个预定义的宏名。它们是:

    _ L I N E _ (两个下划线),对应%d

    _ F I L E _    对应%s

    _ D A T E _   对应%s

    _ T I M E _   对应%s

    _ S T D C _

    如果编译不是标准的,则可能仅支持以上宏名中的几个,或根本不支持。记住编译程序

    也许还提供其它预定义的宏名。

    _ L I N E _及_ F I L E _宏指令在有关# l i n e的部分中已讨论,这里讨论其余的宏名。

    _ D AT E _宏指令含有形式为月/日/年的串,表示源文件被翻译到代码时的日期。

    源代码翻译到目标代码的时间作为串包含在_ T I M E _中。串形式为时:分:秒。

    如果实现是标准的,则宏_ S T D C _含有十进制常量1。如果它含有任何其它数,则实现是

    非标准的。

    可以定义宏,例如:

    当定义了_DEBUG,输出数据信息和所在文件所在行

    #ifdef _DEBUG

    #define DEBUGMSG(msg,date) printf(msg);printf(“%d%d%s”,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

            

    解决方法: #difne DO(a,b) do{a+b;/

                       a++;}while(0)


    宏中"#"和"##"的用法 
    一、一般用法 
    我们使用#把宏参数变为一个字符串,用##把两个宏参数贴合在一起(这里说的是在预处理是对源文件的操作)
    用法: 
    #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))

    三、''#''和''##''的一些应用特例 
    1、合并匿名变量名 
    #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__在第二层才能被解开;

    2、填充结构 
    #define FILL(a)   {a, #a}

    enum IDD{OPEN, CLOSE}; 
    typedef struct MSG{ 
    IDD id; 
    const char * msg; 
    }MSG;

    MSG _msg[] = {FILL(OPEN), FILL(CLOSE)}; 
    相当于: 
    MSG _msg[] = {{OPEN, "OPEN"}, 
    {CLOSE, "CLOSE"}};

    3、记录文件名 
    #define _GET_FILE_NAME(f)   #f 
    #define GET_FILE_NAME(f)    _GET_FILE_NAME(f) 
    static char FILE_NAME[] = GET_FILE_NAME(__FILE__);

    4、得到一个数值类型所对应的字符串缓冲大小 
    #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]

    本文转载自http://hi.baidu.com/ufo008ahw/blog/item/5e943d4f5f49513caec3abd1.html)

    展开全文
  • ``` #include #define A 10; int fun(int a,int b) { return a+b; } int main () { int a=0;...为什么定义变量标识符A可以直接与a进行运算,但是能带入函数内使用, 使用强转类型也可以
  • 带参数定义(函数)

    千次阅读 2017-04-15 09:38:37
    用括号括住每一个参数,并括住的整体定义;用大写字母表示的函数名。 #define SUM(a,b) ((x)+(y)) 在程序中执行:int ret=SUM(1,2);//则该语句被替换为int ret=((1)+(2)),函数进行计算。

    宏函数没有普通函数压栈、跳转、返回等的开销,可以提高程序的效率。

    宏的名字中不能有空格;用括号括住每一个参数,并括住宏的整体定义;用大写字母表示宏的函数名。

    #define SUM(a,b) ((x)+(y))

    在程序中执行:int ret=SUM(1,2);//则该语句被替换为int ret=((1)+(2)),宏函数不进行计算。


    展开全文
  • 2、“##”的作用是将 左右两边的参数做整体字符串拼接替换 3、经过 ## 替换后的内容必须 有一个 同名的 变量与之对应。 4、 只拼接,展开。 5、## 操作 动态函数指针 案例代码 一、定义中 “#”知识点 #的...

       

    目录

    一、宏定义中 “#”知识点

    1、直接转换字符串,不展开。

    2、转换出的结果一定是“字符串”。

    二、宏定义中 ## 知识点

    1、应用场景

    2、“##”的作用是将 左右两边的参数做整体字符串拼接替换

    3、经过 ## 替换后的内容必须 有一个 同名的 变量与之对应。

    4、 只拼接,不展开。

    5、## 操作 动态函数指针 案例代码


    一、宏定义中 “#”知识点

      #的作用是将“#”后面的宏参数进行字符串转换操作,也就是将#后面的参数 两边加上一对双引号,使其成为字符串。

    这里面有几个知识点:

    1、直接转换字符串,不展开。

        这句话的意思是,带参数宏定义也是宏,而不是普通函数,所以要保留宏的基本特性,也就是全部替换,而不展开。示例代码:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define CONVERT(a) 	#a
    
    int main(int argc, char *argv[]) {
    	
    	int a = 6;
    	
    	printf("res:%s\n", CONVERT(a));
    	
    	return 0;
    }

     运行结果:
     

    res:a

    2、转换出的结果一定是“字符串”。

    代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define CONVERT(a) 	#a
    
    int main(int argc, char *argv[]) {
    	
    	printf("string print:%s\n", CONVERT(6));     // 字符串格式打印
    	printf("int print:%d\n", CONVERT(6));     // 整型打印
    	
    	return 0;
    }

     运行结果如下:

    string print:6
    int print:4210688

    二、宏定义中 ## 知识点

    1、应用场景

         ## 的 应用场景主要是 函数指针的动态绑定,使用该宏参数,可以实现 同类型 函数指针 赋值或者引用的 方便操作。这个后面会有代码详细分析。 

    2、“##”的作用是将 左右两边的参数做整体字符串拼接替换

        不管 ## 左右两边是字母还是数字,最终都是作为 一个整体 拼接成一个字符串。代码如下:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define FUNC(a) 	func_##a
    
    void func_1(void)
    {
    	printf("this is func 1.\n");
    }
    
    void func_2(void)
    {
    	printf("this is func 2.\n");
    }
    
    int main(int argc, char *argv[]) {	
    	FUNC(1)();
    	FUNC(2)();
    	return 0;
    }

    3、经过 ## 替换后的内容必须 有一个 同名的 变量与之对应。

       比如 运行 FUNC(1),必须要保证 有一个 func_1 函数, 同样的 FUNC(2) 对应 func_2函数,如果没有,编译会报错,提示对象未 定义。

    4、 只拼接,不展开。

        这个类似于 # ,也是原封不动的转换,并不会进一步展开,比如:

    int i = 1;
    FUNC(i)();

     尽管 i = 1,但是 FUNC(i) 的结果是  func_i,而不是 func_1.,所以我们不能够使用 ## 的时候,自作聪明的使用变量。

    5、## 操作 动态函数指针 案例代码

        在 知识点3中,我们提到 不能使用 变量 和 ## 的结合来实现 动态绑定函数指针,那么我们的程序代码就相对不太方便,尤其是我们 想要定义 一系列的 函数,这些函数主题名相同,但是序号不同,那么这个时候,就推荐使用 结构体  数据结构,代码如下所示:

    #include <stdio.h>
    #include <stdlib.h>
    
    #define FUNC(a) 	func_##a
    
    void func_0(void)
    {
    	printf("this is func 0.\n");
    }
    
    void func_1(void)
    {
    	printf("this is func 1.\n");
    }
    
    void func_2(void)
    {
    	printf("this is func 2.\n");
    }
    
    
    //包含函数 序号、 函数指针的 结构体
    typedef struct func_t{
    	int id;
    	void (*func)(void);
    } func_map_t;
    
    
    // 函数结构体  数组
    static func_map_t  g_func_map[3] = {
    {0, FUNC(0)},
    {1, FUNC(1)},
    {2, FUNC(2)},
    };
    
    int main(int argc, char *argv[]) {	
    
    	g_func_map[0].func();            //间接调用 序号对应的 函数。
    	g_func_map[1].func();
    	g_func_map[2].func();
    	return 0;
    }

        这里需要注意的是,我们在定义 上面的 g_func_map 数组 时,需要 在 函数func_0、func_1、func_2之后,这可能是因为编译器先后顺序的原因,如果g_func_map 在这三个函数之前,那么会出现 编译报错信息,显示 这3个函数未定义,可以简单的认为,在定义的时候,数据类型从 前面 查找, 而不是全局查找。

    运行结果如下:

    this is func 0.
    this is func 1.
    this is func 2.

     

    展开全文
  • 带参数替换

    2018-02-06 20:28:00
    带参数替换因各种需求叠加,替换规则很怪异: 1、首先将实参替换形参,并展开 2、如果1步展开后,有#或者##,那么停止替换。 3、如果1步展开后,没有#或者##,且参数也是,那么继续替换,知道参数没有为止...
  • (1) 修饰局部变量,限定变量的生命周期。变量的存储类别由栈区变为静态数据区。 int main() { int x=9; //普通局部变量,存储在栈区 static int x=9; //静态局部变量,存储在静态数据区 return 0; }  ...
  • C++中交换两个变量的值的方法

    千次阅读 多人点赞 2019-11-05 18:21:03
    能通过将变量名传入函数的方式进行交换,因为这种方式是将值进行拷贝后作为参数传入函数,也就是说函数内部使用的拷贝的值,在函数执行完后就会销毁,而不是对变量的原值进行操作。 而在C++中需要通...
  • C++中可变参数宏定义用法实践

    千次阅读 2019-09-07 14:44:39
    本博文的目的是记录在C++中使用可变参数宏定义的过程,通过一些实际编写的代码查看效果,来熟悉可变参数宏定义的使用方法注意事项。 由于查询的资料来看,这种可变参数宏定义实际表现效果与所用的语言编译器...
  • qt中宏定义及c++中不带参数宏定义

    千次阅读 2018-02-09 14:14:30
    内容提要:下面讲的是qt中宏定义及c++中不带参数宏定义: 宏定义又称为宏代换、宏替换,简称“宏”。 格式: #define 标识符 字符串 其中的标识符就是所谓的符号常量,也称为“宏名”。 预处理(预编译)工作...
  • C语言学习(十七)全局变量 定义

    千次阅读 2019-02-22 20:30:58
    定义在函数外面的变量是全局变量,全局变量具有全局的生存期作用域,它们与任何函数都无关,在任何函数内部都可以使用它们。 例1:全局变量 #include&lt;stdio.h&gt; int f(void); int g=12; //定义全局...
  • 定义和带参函数的区别

    千次阅读 2019-03-04 21:42:56
    在带参定义中,不会为形式参数分配内存,因此不必指明数据类型。而在调用中,实参包含了具体的数据,要用它们去代换形参,因此必须指明数据类型。...而在带参数的宏中,只是符号的替换,存在值传递的问题。 ...
  • SystemVerilog中`define传参 ---带参数的Macro Function 一、用Macro定義簡單的function,使代碼變得簡潔明了 module top ; `define A_SRAM_RW(dst_cc_num,src_cc_num)\ if(strm_sel[``dst_cc_num``] == 1'b1)begin\...
  • 面试中经常考到的一个题。原理跟 a=a+b;...//定义 交换两个变量的值。使用异或运算。 #define SWAP(a,b) {a=a^b; b=a^b; a=a^b;} int main() {  int i, j;  i = 1213;  j = 1314;  SWAP(i, j);  ...
  • 带参数定义

    千次阅读 2014-11-16 09:41:18
    带参数定义的一般形式如下:  #define ()  其中, 是一个标识符,中的参数可以是一个,也可以是多个,视具体情况而定,当有多个参数的时候,每个参数之间用逗号分隔。是被替换用的字符串,体中的字符串...
  • 本章主要内容:创建自定义函数,创建带参数的过程,使用加载工具,小结。
  • SAS中3种定义宏变量方法

    千次阅读 2017-09-19 22:49:59
    SAS中定义宏变量方法主要有以下三种: 一、%LET定义 这是最常用的方法。语法过程为:%let 宏变量名=值;调用宏变量:&宏变量名 Tips: 1、以逗号作为宏变量定义的结束。 2、在定义时候不要加引号,系统会把引号...
  • C语言带参数宏定义

    2016-10-25 09:21:06
    带参数,在调用中,不仅要展开,而且要用实参去代换形参。 带参定义的一般形式为: #define 宏名(形参列表) 字符串 在字符串中含有各个形参。 带参调用的一般形式为: 宏名(实参列表); ...
  • SAS定义宏变量三种方法

    万次阅读 2015-07-03 14:24:06
    SAS 中定义宏变量方法主要有以下三种:  一、%LET定义  这是最常用的方法。语法过程为:%let 宏变量名=值;调用宏变量:&宏变量名  Tips:  1、以逗号作为宏变量定义的结束。  2、在定义时候不要加...
  • c语言中的定义

    千次阅读 多人点赞 2018-11-20 10:15:57
    带参数展开用实参替代形参,发生在预处理阶段。 示例1: #define SUM(x, y) x+x*y+y //定义 10 * SUM(2+2, 3+3) 预期结果为:10 * (4 + 4 * 6 + 6) = ...
  • 首先,我们先来创建一个定义,如下 ...创建完成后,我们要看两个很重要的位置,LABEL(x,y,w,h)CGRectMake(x, y, w, h),我们可以看到,括号里的x,y,w,h,为四个变量参数,也就是说,带参数...
  • 带参数定义 #define

    万次阅读 2015-12-25 20:02:23
    // // main.c // C语言学习 #include //求和函数 int sum(int v1, int v2){ return v1 + v2;...//定义 ... #define 代表要定义一个 ... 定义并不会做任何运算,无论是有参数还是无参数,仅仅是
  • 定义一个带参数,使两个参数的值互换,并写出程序,输入两个数作为使用时的参数。输出已交换后的两个值 首先需要理解的是是如何定义的,然后按照要求完成的处理 #include&lt;stdio.h&gt; #define ...
  • C语言接收函数及其参数

    千次阅读 2016-04-08 10:03:34
    C语言接收函数及其参数标签:c/c++#include #include <stdlib.h>#define call_optimized(function, arguments) {\ printf("\n-------------"); \ printf("\n\tCALL %s\n", #function); \ function argument
  • 全局变量宏定义

    千次阅读 2014-08-25 13:55:54
    以下是如何定义全局变量。...因此,必须在 .C .H 文件中定义。这种重复的定义很容易导致错误。 Error[e46]: Undefined external "SerBfr" referred in ZLG522S D:\mcu\430prj\zlg522s\Debug\Obj\ZLG522S.r43
  • 以符号“#”开头的命令,如: #define N 10; #define <stdio.h> 这些命令不是C语言本身的组成部分,而是由C编译系统提供的。在通常的编译(词法语法分析...所有预处理命令均以“#”开始,末尾加分号,以区别
  • Qt全局宏和变量

    万次阅读 2011-07-07 13:42:55
    1. Qt 全局定义Qt版本号: QT_VERSION : (major 检测版本号:QT_VERSION_CHECK(major, minor, patch)((major当使用命名空间时的一些定义:namespace QT_NAMESPACE {} //命名空间定义#

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 81,221
精华内容 32,488
关键字:

一般变量和不带参数的宏的区别