C/C++错题以及零碎知识点记录

联合体union的所有成员都是从该union首地址开始存放的

---

x&(x-1) 可用于把二进制形式的最低位的1置为0

---

---

---

64位系统有64根地址总线，指针类型都是8字节

---

64位系统有64根地址总线，指针类型都是8字节

---

---

int* a, b;
int* c;
int* d;

---

// p1是一个指针数组，数组有10个元素，每个元素都是指针，每个指针存放一个函数的地址
int (*p1[10])(int*);    

int (*p2)[10](int*); // error

 // p3是一个数组指针，指向含有10个函数指针的数组
int (*(*p3)[10])(int*);

int((int*)[10])* p4; // error

---

---

预处理： 处理​​#​​开头的预处理指令，就是简单的文本替换

编译： 就是把预处理完的文件进行一系列词法分析、语法分析、语义分析及优化后生产相应的汇编文件

汇编： 汇编器将汇编代码转换为对应的机器指令

链接： 将源文件中用到的库函数与汇编生成的目标文件​​.o​​合并生成可执行文件

---

数据类型转换的时候，对于溢出的数据，是采取暴力截取的方式

而指针类型强转，只是改变了指针访问数据的粒度，也就是指针​​++​​时偏移的粒度

实际上指针​​p​​​指向的一字节存放的就是​​f7​​​，但是由于输出格式控制​​%08x​​​，需要以16进制形式显示8位（输出在屏幕上则每位表示一字节数据），于是用符号位补齐，输出为​​fffffff7​​

---

分析：

​​int a[4][4]​​​，a指向一个数组，数组里有4个元素，每个元素的类型都是​​int[4]​​​（严格控制了a[0]和a[1]之间的距离就是​​sizeof(int)*4​​），a的本质是一个数组指针

​​int* a[4]​​​，p指向一个数组，数组里有4个元素，每个元素的类型都是​​int*​​（p[0]和p[1]之间的距离无法确定，要看具体指向的对象），a的本质是一个指针数组

int a[4][4];
    int* p[4];

    int p0[4] = { 0,0,0,0 };
    int p1[4] = { 1,1,1,1 };
    int p2[4] = { 2,2,2,2 };
    int p3[4] = { 3,3,3,3 };
    p[0] = p0;
    p[1] = p1;
    p[2] = p2;
    p[3] = p3;

    for (int i = 0; i < 4; i++) {
        for (int j = 0; j < 4; j++) {
            a[i][j] = 1;
        }
    }

​​ int (*p)[n]​​​，​​()​​优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。也就是说执行p+1时，p要跨过n个整型数据的长度。所以数组指针也称指向一维数组的指针，亦称行指针。

如要将二维数组赋给一指针，应这样赋值：

int a[3][4];
int (*p)[4];  //该语句是定义一个数组指针，指向含4个元素的一维数组。
p = a;        //将该二维数组的首地址赋给p，也就是a[0]或&a[0][0]
p++;          //该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]

int arr1[4][4] = { 1,2,3,4,1,2,3,4,1,2,3,4,1,2,3,4 };
    int arr2[4] = { 5,6,7,8 };
    // arr1和arr2都可以给a赋值
    int(*a)[4] = arr2;

    // 访问的形式就好像用arr1赋值一样
    // 其实a[0]存放的也是一个地址，a[0]和a[1]相差也是16字节
    printf("%d\n", a[0][0]);
    printf("%d\n", a[0][1]);
    printf("%d\n", a[0][2]);
    printf("%d\n", a[0][3]);

参考： ​​数组指针和指针数组的区别​​

---

分析： 表达式​​x&(x-1)​​​可以将x的最后一个1变成0，如果是2的幂，那结果必然是0；对于不是2的幂的数，其二进制表示必然存在不止一个1，此时表达式​​x&(x-1)​​的结果肯定不为0

---

什么是异质链表？
用基类类型指针，可以生成一个连接不同派生类对象的动态链表，即每个结点指针可以指向类层次中不同的派生类对象。这种结点类型不相同链表称为异质链表。

---

B选项：

首先查看指针的类型，类型是Base，然后查看调用的函数在Base中是否是虚函数

1. 不是虚函数，就是编译时期（静态）的类型
2. 是虚函数，就是运行时期（动态）的类型，即RTTI类型

---

在C++中，派生类把基类中所有的成员继承过来，除了构造函数和析构函数

友元函数不属于类，它只是给类开了一个后门。本来类外不可以访问类的私有成员，通过友元函数就可以，如果被继承了，通过这个函数就可以访问基类私有成员，所以不能继承。

子类继承父类，那么默认的，就是继承了父类的成员函数和成员变量。友元函数就是普通的函数，只是能访问类的私有成员，不属于类。

---

---

重载： 重载函数必须在同一作用域，函数名相同，参数列表不同，和返回值无关，virtual关键字可有可无

覆盖： 在继承结构中，派生类中有和基类函数名相同，参数相同，基类函数必须有virtual关键字

隐藏： 如果派生类的函数于基类的函数同名，但是参数不同，此时无论有无virtual关键字，基类的函数都被隐藏

---

构造函数是在静态变量的初始化之前执行的，这句话是否正确？

​​.data​​​段存放初始化且初始化值不为0的数据
​​​.bss​​段存放未初始化和初始化为0的数据

程序启动静态变量就存在数据区，但不会初始化，运行到对应代码后再初始化

---

​​getchar​​​：将输入的字符存放在变量中，遇到​​\n​​​结束，同时也支持输入​​\n​​存放于变量

int a;
    while (1) {
        a = getchar(); // scanf("%c",&a);
        putchar(a);   // printf("a = %c\n", a);
    }

---

#include<stdio.h>
#include<stdlib.h>

void f() {
    printf("f()\n");
}

void g() {
    printf("g()\n");
    atexit(f);  // 在g函数后面挂上f函数 
}

int main() {
    printf("main()\n");
    g();
    return 0;
}

---

注意​​a​​​是数组指针即可，需要知道​​&a+1​​​和​​a+1​​的区别

---

---

---

---

在​​0x0811ff44​​处写入整型10

*(int*)0x0811ff44 = 10;
    new ((int*)0x0811ff44) int(10);

---

全局变量初始化肯定是线程安全的，全局变量初始化在main函数之前，多线程需要在main函数启动

static有加锁控制

---

int main(){
  int a = 1, b = 2, c = 3;
  printf("%d, %d, %d, %d\n", a=b=c, a = (b == c), a==(b=c), a == (b == c)); // 3, 3, 0, 0
  return 0;
}

注：

1. 表达式从右向左计算，所有表达式计算完再从右向左入参，最后才调用printf
2. 若printf输出的是表达式，会直接存放在栈上
3. 从右向左第三个表达式输入3，是因为第三个表达式输出的是a的值，而a在第四个表达式中被修改为3