联合体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中是否是虚函数
- 不是虚函数,就是编译时期(静态)的类型
- 是虚函数,就是运行时期(动态)的类型,即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;
}
注:
- 表达式从右向左计算,所有表达式计算完再从右向左入参,最后才调用printf
- 若printf输出的是表达式,会直接存放在栈上
- 从右向左第三个表达式输入3,是因为第三个表达式输出的是a的值,而a在第四个表达式中被修改为3