C++：x&(x-1)的作用、sizeof计算多种情况详解、宏误区

一、x &(x-1)作用

x &(x-1)作用：将二进制的最后一个1变为0.
通过下图观察，我们可以发现规律：

实例1： 统计1的个数

1.求下面函数的返回值

int func(int x) 
{ 
    int countx = 0; 
    while(x) 
    { 
          countx ++; 
          x = x&(x-1); //判断二进制有几个1
     } 
    return countx; 
} 
int main()
{
	int rt = func(9999);
	cout << rt << endl;
	return 0;
}

功能：将x转化为2进制，看含有的1的个数。
         每执行一次x = x&(x-1)，会将x用二进制表示时最右边的一个1变为0，因为x-1将会将该位(x用二进制表示时最右边的一个1)变为0。
         因此打印结果：8

实例2：判断一个数(x)是否是2的n次方

判断一个数(x)是否是2的n次方

#include <stdio.h>
int func(int x)
{
    if( (x&(x-1)) == 0 )
        return 1;
    else
        return 0;
}
 
int main()
{
    int x = 8;
    printf("%d\n", func(x));
}

功能：判断一个数(x)是否是2的n次方
如果一个数是2的n次方，那么这个数用二进制表示时其最高位为1，其余位为0。返回值类型为size_t
 

二、sizeof计算大小问题

sizeof：判断数据类型长度符的关键字。
作用：sizeof本质是C/C++中的一个操作符（operator），简单的说其作用就是返回一个对象或者类型所占的内存字节数。
返回值：unsigend int
为什么返回值为unsigend int类型？
当一个unsigned int和int类型运算时，编译器会将运算类型都转为unsigned int类型。如图：

//当一个unsigned int和int类型运算时，编译器会将运算类型都转为unsigned int类型
void test()
{
	unsigned int a = 10;
	if (a - 20 > 0)
	{
		printf("大于0\n");
	}
	else
	{
		printf("小于0\n");
	}
}

输出为：大于0，因此：当sizeof(int)-5时

int main()
{
	if(sizeof(int) - 5 > 0)
	{
		printf("大于0\n值为%u\n",sizeof(int)-5);
	}
	else
	{
		printf("小于0\n");
	}
	return 0;
}

验证了其返回值大于0；为unsigend int类型。

实例1：sizeof计算基本类型的长度

类型	大小 (32位)	大小(64位)
char	1	1
unsigned char	1	1
short	2	2
unsigned char	2	2
int	4	4
unsigned int	4	4
long	4	8
unsigned long	4	8
long long	8	8
指针	4	8
float	4	4
double	8	8

 

实例2：sizeof计算结构体、联合体、位段长度

      正确计算sizeof(结构体)的大小，需要理解和掌握数据对齐的概念。数据对齐的概念在前面内存中的数据对齐 和 自然对齐和强制对齐有介绍。关键是记住自然对齐和强制对齐的对齐规则，计算sizeof(结构体)的大小就很简单了。
参见：自定义数据类型
 

实例3：sizeof计算数组长度

普通情况： str是字符数组,由字符串"http://www.ibegroup.com/"初始化,
“http://www.ibegroup.com/”,共24个字符,又字符串以 ‘\0’ 结尾，所以str数组总长度是25。

char str[] = “http://www.ibegroup.com/”

   sizeof(s)为25个字节。

str数组做函数参数：
　　在函数里，数组str作为参数传进来，在函数内部str是指针的形式。所以：例如：实际上计算的为指针大小，这里为32位平台，4个字节

void Foo ( char str[100])
{
　　sizeof( str ) = ?//4个字节,数组作为参数，数组名退化为指针
}

 

实例4：sizeof计算与类相关的大小

4.1sizeof计算空类时，空类大小默认为1。
      因为类的实例化就是给每个实例在内存中分配一块内存地址。空类被实例化时，会由编译器隐含得添加一个字节，所以为1。

class A
{
public:
    A();
    ~A();
private:
};

4.2sizeof计算类时内存对齐问题，static不影响类的大小。
      sizeof(b) = 8。类B中最大类型是int。a长度1字节，b长度1字节，int型c内存地址必须可以被4整除，static变量d不影响类的大小。

class B
{
public:
	
protected:
    char a;
    char b;
    int c;
    static int d;
};

4.3继承与sizeof计算问题：要包含子类的大小
      sizeof(B) = 12。B继承A，所以B中包含了A中的所有数据，大小为A+B大小= 12 。

class A
{
protected:
    int a;
private:
    int b;
};
class B :public A
{
private:
    int c;
};

4.4单个虚函数与sizeof计算问题：要包含指向虚函数表的指针
       计算大小为4，因为类C中包含一个指向虚函数表的指针。

class C
{
    virtual void fun(){}
};

4.5多个虚函数与sizeof计算问题：多个虚函数只需要一个指向虚函数表的指针
计算大小还是为4。

class D
{
    virtual void fun1()    {}

    virtual void fun2() {}
};

 

实例5：sizeof与strlen对比

      strlen：是求字符串实际长度的函数，strlen所作的仅仅是一个计数器的工作，它从内存的某个位置（可以是字符串开头，中间某个位置，甚至是某个不确定的内存区域）开始扫描，直到碰到第一个字符串结束符’\0’为止，然后返回计数器值(长度不包含’\0’，sizeof包含‘\0’)。

char *p1 = "12345678"; 
char p2[] = "12345678"; 
char p3[1024]="12345678"; 
char p4[] = {'1','2','3','4','5','6','7','8'}; 

int main()
{
	cout<<"sizeof(p1):"<<sizeof(p1)<<endl;
	cout<<"sizeof(p2):"<<sizeof(p2)<<endl;
	cout<<"sizeof(p3):"<<sizeof(p3)<<endl;
	cout<<"sizeof(p4):"<<sizeof(p4)<<endl;

	cout<<"strlen(p1)"<<strlen(p1)<<endl;
	cout<<"strlen(p2)"<<strlen(p2)<<endl;
	cout<<"strlen(p3)"<<strlen(p3)<<endl; 
	cout<<"strlen(p4)"<<strlen(p4)<<endl; 

	return 0;
}

计算结果如图所示：

p1: 为一个字符指针，指向了静态常量区的一个常量字符串，“12345678”。所以，sizeof(p1)=指针的长度=4；strlen(p1)=字符串"12345678"的长度（不含’\0’)，所以是8。
p2: 为一个字符数组，由静态常量区的"12345678"进行初始化。所以sizeof(p2)是计算数组p2的长度，所以结果为"12345678"的所有字符的长度(含’\0’)，所以是9。 strlen(p2)也是在计算"12345678"的长度（不含’\0’)，所以是8。
p3： 为一个字符数组，由静态常量区的"12345678"进行初始化，但长度为1024。 所以，sizeof(p3)=1024;strlen(p3)为字符串"12345678"的长度（不含’\0’)，所以是8。
p4： 为一个字符数组，由字符’1’,‘2’,‘3’,‘4’,‘5’,‘6’,‘7’,‘8’进行初始化，,这样初始化与"12345678"进行初始化的区别是 前者不包含’\0’.因此，sizeof(p4)=8。由于p4作为一个字符数组，并不以’\0’结尾， 所以strlen(p4)在计算字符串长度的时候，找不到结束符’\0’，会发生字符串溢出。 字符串溢出，值不确定，甚至会引起程序崩溃
 

三、宏误区

宏： 是一种批量处理的称谓。计算机科学里的宏是一种抽象，它根据一系列预定义的规则替换一定的文本模式。解释器或编译器在遇到宏时会自动进行这一模式替换。对于编译语言，宏展开在编译时发生，进行宏展开的工具常被称为宏展开器。
实例1：

#define DOUBLE(x) x+x

int main()
{
	int rt = 5*DOUBLE(10);
	cout<< rt << endl;
	return 0;
}

这段代码输出结果为：60

为什么？正如定义所描述的，宏展开在编译时发生，会展开替换为实际的语句。当编译到int rt = 5* DOUBLE(10);时，会自动展开替换为：5*10+10=60
但是如果我们将上述代码改为：

#define DOUBLE(x) x+x//宏在编译时要展开

int main()
{
	int rt = 5*(DOUBLE(10));
	cout<<rt<<endl;
	return 0;
}

此时：我们在int rt = 5*(DOUBLE(10));加了一个括号，输出结果为：100
这就是宏替换时我们没有注意到的小细节，以后还是要认真审题呀！