• [C++基础] 预处理篇


    预处理篇

    1 C/C++头文件中的 ifndef/define/endif 的作用是什么?

    如果一个项目中存在两个C文件,而这两个C文件都 include (包含)了同一个头文件, 当编译时,这两个C文件要一同编译成一个可运行文件,可能会产生大量的声明冲突。所以要把头文件的内容都放在 #ifhdef 和 #endif 中,防止该头文件被重复引用。


    2 #include <filename.h>和#include “filename.h” 有什么区別?

    对于 #include <filename.h>编译器先从标准库路径开始搜索 filename.h,然后才去用户的工作路径搜索,使得系统文件调用较快。

    对于 #include “filename.h”编译器先从用户的工作路径开始搜索 filename.h,然后才去标准库路径搜索,使得自定义文件调用较快。


    3 头文件的作用有哪些?

    头文件的作用主要表现为以下两个方面:

    (1)通过头文件来调用库功能。出于对源代码保密的考虑,源代码不便(或不准)向用户公布,只要向用户提供头文件和二进制的库即可。用户只需要按照头文件中的接口声明来调用库功能,而不必关心接口是怎么实现的。编译器会从库中提取相应的代码。

    (2)头文件能加强类型安全检查。如果某个接口被实现或被使用时,其方式与头文件中的声明不一致,编译器就会指出错误,能大大减轻程序员调试、改错的负担。


    4 #define有哪些缺陷?

    由于宏定义在预处理阶段进行,主要做的是字符替换工作,所以它存在着一些固有的缺陷:

    (1)它无法进行类型检查。宏定义是在编译前进行字符的替换,因为还没编译,不能编译前就检查好类型是否匹配,而只能在编译时才知道,所以不具备类型检查功能。

    (2)由于优先级的不同,使用宏定义时,可能会存在副作用。例如,执行加法操作的宏定义运算 #define ADD(a,b) a+b 在使用的过程中,对于表达式的运算就可能存在潜在的问题,而应该改成 #define ADD(a,b) ((a)+(b))

    (3) 无法进行单步调试。

    (4)会导致代码膨胀。由于宏定义是文本替换,需要对代码进行展开,相比较函数调用的 方式,会存在较多的冗余代码。

    (5)在C++中,使用宏无法操作类的私有数据成员。


    5 如何使用define声明一个常数,用以表明1年中有多少秒(忽略闰年间题)?

    #define SECOND_PER_YEAR (365*24*60*60)UL
    

    考虑到可能存在数据溢出问题,更加规范化的写法是使用长整型类型,即UL类型, 告诉编译器这个常数是长整型数。


    6 不能使用大于、小于、if语句,如何定义一个宏来比较两个数a、b的大小?

    如果只是进行简单的比较,则返回比较结果即可,宏定义可以写为如下方式:

    #define check(a,b)   (((a)-(b))=fabs((a)-(b)))? “greater”: “smaller”   
    

    但如果需要返回较大的值,则宏定义可以写为:

    #define MAX(a,b) (fabs((a)-(b))=((a)-(b))?(a):(b))
    

    虽然 #define MAX(a,b) (abs((a)-(b))=((a)-(b))?(a):(b)) 也是一种比较好的做法,但是函数 abs() 接收的参数及其返回值都是整数,这样在传递实参时,其小数部分可能被截去,从而导致误差。例如,a=-12.345b=-24.1467abs((a)-(b)) 返回值为 12,但 (a)-(b) 显然不等于 12。

    fabs() 所接受的参数及返回值都是 double 型的,这样无论它是接受整数还是接受 float 型的数据,都不会因精度问题而出现误差。


    7 如何判断一个变量是有符号数还是无符号数?

    采用取反操作。

    对于这个变量分两种情况进行分析,一种情况是它为某种类型的值,另一种情况是它为某种类型。对于值而言,如果这个数以及其求反后的值都大于0,则该数为无符号数,反之则为有符号数,因为数据在计算机中都是以二进制的0或1存储的,正数以0开头,负数以1开头,求反操作符会把所有的1改为0,所有的0改为1。如果是有符号数,那么取反之后,开头的0会被改为1,开头的1会被改为0,开头为1时即表示该数为负数,如果是无符号数则不会受此影响。对于类型而言,也同样适用。

    对于为值的情况,可以采用如下宏定义的方式:

    #defme ISUNSIGNED(a) (a>=0 && ~a>=0)
    

    对于为类型的情况:

    #define ISUNSIGNED(type) ((type)O-l > 0)
    

    程序示例代码如下:

    #include <stdio.h>
    
    #define ISUNSIGNED(a)	(a >= 0) && (〜a >= 0)
    #define ISUNSIGNED_TYPE(type) ((type)O-l > 0) 
    
    int main()
    {
    	int a = 0;
    	unsigned int b = 0;
    	
    	printf("%d 
    ", ISUNSIGNED(a));
    	printf("%d 
    ", ISUNSIGNED(b));
    	printf("%d 
    ", ISUNSIGNED_TYPE(int));
    	printf("%d 
    ", ISUNSIGNED_TYPE(unsigned int));
    	
    	return 0;
    }
    

    程序输出结果:

    0
    1
    0
    1
    

    8 #define TRACE(S) (printf("%s ",#S),S) 是什么意思?

    # 进行宏字符串连接,在宏中把参数解释为字符串,不可以在语句中直接使用。在宏定义中printf("%s ", #S)会被解释为printf("%s ”,”S”)

    程序示例如下:

    #include <stdio.h>
    
    #define TRACE(S) (printf("%s
    ", #S),S) 
    
    int main()
    {
    	int a = 5;
    	TRACE(a);
    
    	char *str = "hello";
    	char des[20];
    	strcpy(des,TRACE(str));
    	printf("des=%s
    ",des);
    	
    	return 0;
    }
    

    程序输出结果:

    a
    str
    hello
    
    

    上例中,宏定义又是一个逗号表达式,所以复制到des里面的值为后面S也就是str的值。所以最后输出的就是字符串hello了。


    9 不使用 sizeof,如何求变量占用的内存空间大小?

    (1)使用宏定义的方式:

    #include <stdio.h>
    
    #define MY_SIZEOF(value) ( (char *)(&value+1) - (char *)&value )
    
    int main()
    {
    	int i; 
    	double f; 
    	double a[4]; 
    	double *q;
    	
    	printf("%d
    ",MY_SIZEOF(i)); // 4
    	printf("%d
    ",MY_SIZEOF(f)); // 8
    	printf("%d
    ",MY_SIZEOF(a)); // 32
    	printf("%d
    ",MY_SIZEOF(q)); // 4
    	
    	return 0;
    }
    
    
    

    注意使用#define MY_SIZEOF(value) ( (&value+1) - &value ),返回的是 1(偏移单位长度),而不是 4。


    (2)使用函数的方式:

    #include <iostream>
    using namespace std;
    
    template <class T>
    int getSize(T *p)
    {
        return int(p+1)-int(p);
    }
    
    int main()
    {
    	int* i; 
    	double* q; 
    	char a[10];
    	
    	printf("%d
    ",getSize(i)); // 4
    	printf("%d
    ",getSize(q)); // 8
    	printf("%d
    ",getSize(&a)); // 10
    	
    	return 0;
    }
    
    
    

    注意使用#return (p+1)-(p);,返回的是 1(偏移单位长度),而不是 4。


    10 如何使用宏求结构体的内存偏移地址?

    #define OFFSET(type,field) ( (size_t)&(((type *)0)->field) )
    
    

    在 C 语言中,ANSI C 标准允许值为 0 的常量被强制转换成任何一种类型的指针,而且转换结果是一个空指针,即 NULL 指针,因此对 0 取指针的操作 ((type *)0)的结果就是一个类型为 type* 的NULL指针。但如果利用这个 NULL 指针来访问 type 的成员当然是非法的,但可以用来计算 field 字段的地址。

    C 语言编译器根本就不生成访问 type 的代码,而仅仅是根据 type 的内容布局和结构体实例首址在编译期计算这个(常量)地址,这样就完全避免了通过 NULL 指针访问内存可能出现的问题。同时又因为地址为 0,所以这个地址的值就是字段相对于结构体基址的偏移。


    程序示例如下:

    #include <stdio.h>
    
    #define OFFSET(type,field) ( (size_t)&(((type *)0)->field) )
    
    struct MyStr
    {
    	char a; // 4byte (由于下一个成员为4个字节的,为了字节对齐,补齐为4个字节)
    	int b;  // 8byte
    	float c; // 16byte (由于下一个成员为8个字节的,为了字节对齐,补齐为8个字节)
    	double d; // 24byte
    	char e; // 32byte (要是最大长度的整数倍)
    };
    
    int main()
    {
    	printf("%d
    ",OffSet(MyStr,a)); // 0
    	printf("%d
    ",OffSet(MyStr,b)); // 4
    	printf("%d
    ",OffSet(MyStr,c)); // 8
    	printf("%d
    ",OffSet(MyStr,d)); // 16
    	printf("%d
    ",OffSet(MyStr,e)); // 24
    	printf("%d
    ",sizeof(MyStr)); // 32
    	
    	return 0;
    }
    
    

    上述方法避免了实例化一个type对象,而且求值在编译期进行,没有运行期负担,程序效率大大提高。


    11 枚举和 define 有什么不同?

    具体而言,两者的区别表现在以下几 个方面:

    (1)枚举常量是实体中的一种,而宏定义不是实体。

    (2)枚举常量属于常量,但宏定义不是常量。

    (3)枚举常量具有类型,但宏没有类型,枚举变量具有与普通变量相同的性质,如作用域、值等,但是宏没有。

    (4)宏常量是在预编译阶段进行简单替换,枚举常量则是在编译的时候确定其值。

    (5)—般在编译器里,可以调试枚举常量,但是不能调试宏常量。

    (6)枚举可以一次定义大量相关的常量,而#define宏一次只能定义一个。


    12 typdef 和 define 有什么区别?

    typedef 与 define 都是替一个对象取一个别名,以此来增强程序的可读性,但是它们在使用和作用上也存在着以下几个方面的不同:

    (1)原理不同。#define 是 C 语言中定义的语法,它是预处理指令,在预处理时进行简单的字符串替换,不作类型检查,不管含义是否正确照样带入,只有在编译己被展开的源程序时才会发现可能的错误并报错。typedef 是关键字,它在编译时处理,所以typedef有类型检查的功能。

    (2)功能不同。typedef 只是用来定义类型的别名,这些类型不只包含内部类型(int、char 等),还包括自定义类型(如 struct),可以起到使类型易于记忆的功能。#define 不只是可以为类型取别名,还可以定义常量、变量、编译开关等。

    (3)作用域不同。#define 没有作用域的限制,只要是之前预定义过的宏,在以后的程序中都可以使用,而 typedef 有自己的作用域。

    void fun()
    {
    	#define A int                                           
    }
    
    void gun()
    {
    	// 在这里也可以使用A,因为宏替换没有作用域,但如果上面用的是typedef,那这里就不能用 
    	// 不过一般不在函数内使用typedef
    }
    
    

    (4)对指针的操作不同。两者修饰指针类型时,作用不同。

    #define INTPTR1 int*
    typedef int* INTPTR2;
    
    INTPTR1 pl,p2;
    INTPTR2 p3,p4;
    
    

    INTPTR1 p1,p2;INTPTR2 p3,p4;这两句的效果截然不同的。前者进行字符串替换后变成int* p1,p2;,要表达的意义是声明一个指针变量 p1 和一个整型变量 p2。而后者由于 INTPTR2 是具有含义的,告诉我们是一个指向整型数据的指针,那么 p3 和 p4 都为指针变量。


    13 C++ 中宏定义与内联函数有什么区别?

    两者的区别主要表现在以下几个方面:第一,宏定义是在预处理阶段进行代码替换,而内联函数是在编译阶段插入代码;第二,宏定义没有类型检查,而内联函数有类型检查。


    14 不使用第三方变量,如何交换两个变量的值?

    #include <iostream>
    
    using namespace std;
    
    #define swap1(x,y) x=x+y,y=x-y,x=x-y
    
    #define swap2(x,y) x^=y,y^=x,x^=y
    
    int main()
    {
        int a=1,b=2;
        //方法1 - 算数法
        swap1(a,b);
        cout << "a=" << a << " b=" << b << endl;
    
        //方法2 - 异或法
        a=1,b=2;
        swap2(a,b);
        cout << "a=" << a << " b=" << b << endl;
    }
    
    

  • 相关阅读:
    POJ 1061
    LightOJ 1104
    扩展欧几里得算法
    2015 HUAS Summer Trainning #5 E
    2015 HUAS Summer Trainning #5 C
    2015 HUAS Summer Trainning #5 B
    2015 HUAS Summer Trainning #5 A
    2015 HUAS Summer Trainning #4 D
    2015 HUAS Summer Trainning #4 C
    2015 HUAS Summer Trainning #4 B
  • 原文地址:https://www.cnblogs.com/linuxAndMcu/p/9867008.html
Copyright © 2020-2023  润新知