c语言中 x4=0xAB是否正确,C语言基础类错题-CSDN博客

在c++中，

输出是多少？

0，1

1，1

1，0

0，0

如果将i更改为volatile const int类型的，编译器就不会对变量i做优化，printf输出的结果就为1。

下面描述正确的是

p1和p2申请的空间里面的值都是随机值

p1和p2申请的空间里的值都已经初始化

p1申请的空间里的值是随机值，p2申请的空间里的值已经初始化

p1申请的空间里的值已经初始化，p2申请的空间里的值是随机值

下面说法正确的是：

(a>0 )&&(b>0)为真

c==a 为真

b的16进制为0xffffffe0

都不对

a-------1110 0000-----因为是有符号数,负数-----取反+1 0010 0000----- -32

b-------高位按符号位补齐-------ff ff ff e0

c-------224

设

、

均为

int

型变量，则执行语句：

t=3; x=y=2; t=x++||++y;

后，变量

和

的值分别为

____

1,2

||返回0或者1

在一个64位的操作系统中定义如下结构体：

同时定义fool函数如下：

上述fool()程序的执行结果为()

1，0，0

1，1，0

0，1，1

0，0，1

考点：字节对齐，低地址到高地址

因为字节对齐的原因，所以id占用4个字节，value和timestamp分别是4个字节、8个字节。虽然id占用四个字节的地址，但是只有低两位地址的数值有效(字节对齐的机制，即value存储时的地址对4(自身对齐值)求余应为0)。所以id为 0001 0001，高四位无效，所以为0001，value与timestamp分别为0.

比如：地址从0x0000开始，id存储地址本来为0x0000-0x0001，但value存储地址要从0x0004开始，因为0x0004%4==0，所以id存储地址为0x0000-0x0003, value存储地址为0x0004-0x0007, timestamp存储地址为0x0008-0x000F. 所以id == 0x00010001，去掉高4位，id=0x0001，其余为0.

经验：1、表示为习惯意义上的从高向低位写高---》低 0010=2

2、小端机从右向左读，读的时候元素间的字节外从右向左元素内的字节内还是从左向右

nt main()

{

long long a=1;

long long b=2;

long long c=3;

printf("%d,%d,%d",a,b ,c);

return 0;

}

输出结果是什么？(32位环境，cpu为小端模式，所有参数用栈传递)

1、printf从右向左，压栈顺序c,b,a，栈从高向低，c在高位。

2、我们先表示为平常理解的方式高-->低，例如：1001 正常大端机器上：

【00 00 00 00 00 00 00 03】【00 00 00 00 00 00 00 02】【00 00 00 00 00 00 00 01】

大端机器读取，从左向右，%d为4字节，读取为0,3,0

小端机相当于从右向左读取，每次读取4个字节，1,0,2

unsigned int a= 0x1234;

unsigned char b=*(unsigned char *)&a;

在32位大端模式处理器上变量b= ？。

高--->低 00 00 12 34 大端机从左向右读取1个字节 00

在

x86

的机器上，

int a=0xabcd1234 char b=

((

char*

)

[0]

请问

是多少0x34

高向低 ab cd 12 34

X86小端机、1字节

在小端序的机器中,如果

如果:

X a;

a.x=0x11223344;//16 进制则:______

a.y[0]=11

a.y[1]=11

a.y[2]=11

a.y[3]=11

a.y[0]=22

a.y[3]=22

union类型，数据时重叠在同一块内存区域上的，这个内存区域的大小为对其后的最大长度，这里就是4

高--->低 11 22 33 44

小端从左向右取 y[3]=11

这个题的为难之处呢，就在于前面定义结构体里面用到的冒号，如果你能理解这个符号的含义，那么问题就很好解决了。这里的冒号相当于分配几位空间，也即在定义结构体的时候，分配的成员a 4位的空间， b 5位，c 7位，一共是16位，正好两个字节。下面画一个简单的示意：

变量名位数

test 15 14 13 12 11 10 9 |8 7 6 5 4 |3 2 1 0

test.a | |0 0 1 0

test.b |0 0 0 1 1 |

test.c 0 0 0 0 0 0 0 | |

高--->低，从右读，每次都一个字节

在执行i=*((short *)&test); 时，取从地址&test开始两个字节(short占两个字节)的内容转化为short型数据，即为0x0032，再转为int型为0x00000032，即50

问题：在80X86架构下，输出什么值？

-128

-256

128

256

char类型的取值范围是-128～127，unsigned char的取值范围是0～256

这里a[0]=256,出现了正溢出，将其转换到取值范围内就是0，即a[0]=0;

同理，a[1]=-1, a[2]=-2, a[3]=-3,在C语言标准里面，用补码表示有符号数，故其在计算机中的表示形式如下：

a[0]=0, 0000 0000

a[1]=-1, 1111 1111

a[2]=-2, 1111 1110

a[3]=-3, 1111 1101

小端机器中：

1111 1101 1111 1110 1111 1111 0000 0000

short是2字节(a[0]和a[1])，由于80X86是小端模式，即数据的低位保存在内存的低地址中，而数据的高位保存在内存的高地址中，在本例中，a[0]中存放的是b的低位，a[1]中存放的是b的高位，即b的二进制表示是：1111 1111 0000 0000，表示-256，故选B。

在32位小端的机器上，如下代码输出是什么：

0x201 ， 0x403 ， 0x807060504030201 ， 0x0

0x201 ， 0x605 ， 0x807060504030201 ， 0x0

0x201 ， 0x605 ， 0x4030201 ， 0x8070605

0x102 ， 0x506 ， 0x102030405060708 ， 0x0

小端机器的数据高位字节放在高地址，低位字节放在低地址。x86结构为小端模式。

pshort占用2个字节，在内存中的16进制为0x01 0x02，对应的16进制数为0x0201。

pshort + 2指向array数组的下标为4的元素，占用2个字节，在内存中的16进制为0x05 0x06，对应的16进制数为0x0605。

pint64的int64类型不确定，但根据名字可以看出占用8个字节，对应的16进制形式为0x807060504030201。

pint + 2占用4个字节，指向的array数组的下标为8的元素，8-11个元素没有指定数组的初始化值，默认为0，因此*(pint + 2)对应的16进制为0。

以下代码执行后，val的值是___:

20992

21064

b << 8 = 0x5200

val = 0x5200 | 0x48 = 0x5248 = 21064

写出一下程序的输出

254

255

256

死循环

选D

这里num值一直是0，num < 255一直是成立的，程序进入死循环

下面这个程序执行后会有什么错误或者效果:

数组越界

死循环

栈溢出

内存泄露

-1

100

死循环

Unsigned int型数字最小为0，因此不是死循环，a到0就跳出循环，最后输出0

使用printf函数打印一个double类型的数据，要求：输出为10进制，输出左对齐30个字符，4位精度。以下哪个选项是正确的？

%-30.4e

%4.30e

%-30.4f

%-4.30f f： double精度浮点数 e：科学计数法

用C++语法来看，下列的哪个赋值语句是正确的？

char a=12

int a=12.0

int a=12.0f

int a=(int)12.0

A项在赋值为0-127时无警告，但B/C/D均有损失精度的警告，编译还是能通过的。B、C、D项的区别是：B 项的默认为double型转向int型，C项因等号后“12.0f”的 ‘f’使其转换为folate型，D项直接通过在等号的右边加“(int)”强制类型转换，与B项相同的是：是从默认的double型转换为int型。A项会对应的ASCII字符，但在大于127时会发生常量截断会有警告。

以下程序的输出结果为

#include "stdio.h"

int func(int x, int y)

{

return (x + y);

}

int main()

{

int a = 1, b = 2, c = 3, d = 4, e = 5;

printf(" % d\n", func((a + b, b + c, c + a), (d, e)));

return 0;

}

主要知识点是C++中的逗号操作符！ C++ Primer第4版中145页关于逗号操作符论述如下：

逗号表达式的结果是其最右边表达式的值，但是是从左向右计算

以下选项中合法的实型常量是？

3.13e-2.1

.914

2.0*10

A选项为整型数据。B选项中e后面必须为整数。D选项是表达式,不是常量,所以选择C。

有如下程序段：

请问执行结果是：

无限循环

浮点数有精确度的限制吧。所以肯定不能除尽，不能使用==和！=，以及位运算

下面两段代码中for循环分别执行了多少次？

32767 16383

答案分析：unsigned short能表示216个数，其范围为0~216-1，j在i前2个位置，i以5的速度增长，j以7的速度增长，当增长到unsigned short表示的最大值又会返回0(以一个圈的形式循环)开始重新走直到i、j相遇，所以就是7t - 5t + 2 = 216，所以为32767次

第二个类似 (7t + 7)-(5t - 3) = 216,所以为16383次

下面有关C++的类和C里面的struct的描述，正确的有？

来自class的继承按照private继承处理，来自struct的继承按照public继承处理

class的成员默认是private权限，struct默认是public权限

c里面的struct只是变量的聚合体，struct不能有函数

c++的struct可有构造和析构函数

有变量int i = 0; int a = i++; int b=++a; int c = a+b; 请问表达式 a?b:c 的值是

a=i++. a----0

b=++a. b----1. a----1

c=a+b. c-----2

a?b:c a为1取b 也就是1

当参数*x==1, *y==1, *z==1时，下列不可能是函数add的返回值的( )?

开始不知道啥意思，后经牛客网的大神指点才知道这题要考虑的是，x，y，z三个参数是否指向同一地址(或者说调用该函数时是否实参相同)，如：当a=b=c=1时，add(&a,&a,&a)，add(&a,&b,&c)。

通过写程序测试得出结果，不可能得到答案7。

有以下5种情况

问x等于什么？

随机值

如果是函数外定义那么是0

如果是函数内定义，那么是随机值，因为没有初始化

数字字符0的ASCII值为48,若有以下程序:

程序运行之后的输出结果是:

注意初始化时的数据类型，为char型，即此时int(a)=49，int(b)=50。第一条输出变量b的char类型，即char(b)=2，输出后int(b)自增=51，第二条输出整形即int(b-a)=51-49=2。

(1.3)函数类

从下列函数原形看，用GCC编译时，返回值类型为int的函数有？

char F1(int n);

int F2(char n);

F3(int n);

int *F4(int n);

函数原型格式：

函数返回值函数名([形参表]);

A:返回char类型

C：默认返回类型为int类型

D：返回整型指针类型

如果没有返回值，必须声明为void类型

设有以下函数void fun(int n,char *s)(......),则下面对函数指针的定义和赋值均是正确的是：()

void (*pf)(int，char); pf=&fun;

void (*pf)(int n，char *s); pf=fun;

void *pf(); *pf=fun;

void *pf(); pf=fun;

B. 函数指针只需要把fun 改成(*pf) ,赋值直接 pf = fun;即可函数名赋值.指针函数赋值时候,可以直接用函数名赋值(书上一般都是这样赋值的) .但是也可以用&fun ,取地址操作符复制给函数指针. pf = &fun;也是可以的.亲测过

程序出错在什么阶段__？

预处理阶段出错

编译阶段出错

汇编阶段出错

链接阶段出错

运行阶段出错

程序运行正常

http相当于一个label，//www.taobao.com是注释，所以答案错误，可以运行

(1.3.1)重载类

不能作为重载函数的调用的依据是：

参数个数

参数类型

函数类型

函数名称

std::vector::iterator重载了下面哪些运算符？

*(前置)

在重载运算符函数时，下面()运算符必须重载为类成员函数形式()

只能使用成员函数重载的运算符有：=、()、[]、->、new、delete。

如果友元函数重载一个运算符时，其参数表中没有任何参数则说明该运算符是：

一元运算符

二元运算符

选项A)和选项B)都可能

重载错误

友元函数重载时,参数列表为1,说明是1元,为2说明是2元成员函数重载时,参数列表为空,是一元,参数列表是1,为2元

类成员函数的重载、覆盖和隐藏区别描述正确的有？

覆盖是指在同一个类中名字相同，参数不同

重载是指派生类函数覆盖基类函数，函数相同，参数相同，基类函数必须有virtual关键字

派生类函数与基类函数相同，但是参数不同，会"隐藏"父类函数

函数名字相同，参数相同，基类无virtual关键字的派生类的函数会"隐藏"父类函数

a.成员函数被重载的特征：

(1)相同的范围(在同一个类中)；

(2)函数名字相同；

(3)参数不同；

(4)virtual 关键字可有可无。

b.覆盖是指派生类函数覆盖基类函数，特征是：

(1)不同的范围(分别位于派生类与基类)；

(2)函数名字相同；

(3)参数相同；

(4)基类函数必须有virtual 关键字。

c.“隐藏”是指派生类的函数屏蔽了与其同名的基类函数，规则如下：

(1)如果派生类的函数与基类的函数同名，但是参数不同。此时，不论有无virtual关键字，基类的函数将被隐藏(注意别与重载混淆)。

(2)如果派生类的函数与基类的函数同名，并且参数也相同，但是基类函数没有virtual 关键字。此时，基类的函数被隐藏(注意别与覆盖混淆)

(1.3.2)静态类

关于static用途说法正确的是？

声明静态外部类

声明静态外部全局变量

声明静态外部函数

声明静态局部变量

下面对静态成员的描述中，正确的是：

静态数据成员可以在类内初始化

静态数据成员不可以被类对象调用

静态数据成员不能受private控制符的作用

静态数据成员可以直接用类名调用

1、静态数据成员同样受 private,public,protected 等权限符限制

2、静态数据成员由于是属于整个类的，静态数据成员存储在静态数据区。静态数据成员定义时要分配空间，所以不能在类声明中定义(即初始化)，对它们的初始化一般在类外，但是，当类型为const static时的整形时可以在类体内进行初始化。3、可以通过累的对象，指针，类名等直接调用静态成员4、类的静态成员函数可以在类内进行定义，也可以在类外，类的静态成员函数只能直接调用静态成员，如果想调用非静态成员只能通过间接的方式，而非静态成员可以直接访问静态成员。

Fill the blanks inside class definition

Running result : 0 20 1 20

static/const

const/static

--/static

conststatic/static

None of above

对于成员变量a，若它为const类型，那么必须要使用Test::Test(int _a , int _b) : a( _a )这种初始化形式，若它为普通成员变量，也可以采取Test::Test(int _a , int _b) : a( _a )这种形式，所以a可以为const或者普通类型，由于b没有采取Test::Test(int _a , int _b) : b( _b )这种形式，所以b一定不是const类型，有main()中的t1.b和t2.b的输出都是20可以知道，b是静态变量。