Q1. Is the output of this code True or False?
#include
int main(void)
{
int b = 20;
int* y = &b;
char n = 'A';
char* z = &n;
y[0] = z[0];
printf((*y == *z) ? "True" : "False");
}
A. True
B. False
C. Program would crash
D. Compilation error回答：
A. True解释：
二进制形式20是10100，它存储在内存中。由于它是int类型的，因此将分配四个字节并将10100存储在第0个位置。我们从左到右访问数组的元素。但是，在存储器中，存储器的位(并非在所有阵列中)都是从右到左访问的。 ASCII值存储在仅第0个位置的另一个1字节块中。当我们将y [0]等于z [0]时，我们将间接覆盖b的值。这使两个指针相等。
Q2. What is the output of this program?
#include
#include
int main(void)
{
char x = 'A';
char* y = (char*)malloc(sizeof(char));
y = &x;
for (int i = 0; i < 26; i++) {
printf("%c", x);
y[0] += 1;
}
}
A. SDKJNSDNSKDJNSKDVNSKJD
B. SLKFVMSLFKVSFLALKDJF
C. ABCDEFGHIJKLMNOPQRSTUVWXYZ
D. NONEOFTHEABOVE回答：
C. ABCDEFGHIJKLMNOPQRSTUVWXYZ解释：
分配给字符的空间仅为1字节或8位。在运行时分配y。它包含x的地址。现在，我们可以索引x的内存位置。而且，对y的任何更改也会在x中反映出来。当执行y [0] + = 1时，在每个循环中，该1字节数据中的最后一位将递增1，例如：
Initial:
00001010 (Binary form of 'A')
In loop
00001010 + 1 = 00001011 = B
00001011 + 1 = 00001100 = C
00001100 + 1 = 00001101 = D
and goes on up till Z.
注意：尝试索引y [1]和任何其他位置会产生垃圾值。
Q3. What gets printed at the end of this program?
#include
int main(void)
{
int a = 20, b = 10;
int *x = &a, *y = &b;
int c = y[0], d = x[0];
x[0] = c;
y[0] = d;
printf("%d %d", *x, *y);
}
A. 20 20
B. 20 10
C. 10 10
D. 10 20回答：
D. 10 20解释：
在此，仅改变a和b的第0位，从而导致值的改变。
Q4. Is the value of a at the end of the program same as the beginning?
#include
int main(void)
{
int a = 100;
char* b = (char*)&a;
b[0] += 132;
b[1] += 3;
b[0] = (232 - 32) / 2;
b[1] *= 0;
printf("%d\n", a);
}
A. Yes
B. No
C. Program would crash
D. Compilation error回答：
A. Yes解释：
二进制值100是01100100，132是10000100，3是00000011。
b[3] b[2] b[1] b[0]
00000000 00000000 00000000 01100100
+00000000 00000000 00000011 10000100
------------------------------------
00000000 00000000 00000011 11101000
This gives 1000.
现在再次替换值。 232-32为200，然后将其除以2得到100，并在b [0]处将其替换。因此，11101000变为01100100。b [1] * = 0使b [1]的所有8位= 0。这给出的a的输出为100，与开始时相同。
Q5. What happens to this program?
#include
struct A {
int a;
} A1;
struct B {
int b;
} B1;
int main(void)
{
A1.a = 10;
B1.b = 100;
char* x = (char*)&A1;
char* y = (char*)&B1;
y = (char*)0x100;
x[0] = y[1];
printf("%d\n", A1.a);
printf("%d", B1.b);
}
A. Compilation error
B. Segmentation Fault
C. Output would be returned
D. None of the above回答：
B. Segmentation Fault解释：
该程序将崩溃，因为y指向0x100，这是其他正在运行的程序的地址。
Q6. What is the output of this program (Consider address of x as 62fe14)?
#include
int main(void)
{
int a = 100;
char* x = (char*)&a;
char** y = &x;
y[0] = (char*)0x62fe14;
printf("%x\n", x);
printf("%x", *y);
}
A. 0x0010
0x1902
B. Crash
C. 0x62fe14
0x62fe15
D. 0x62fe14
0x62fe14回答：
D. 0x62fe14
0x62fe14解释：
y [0]已包含0x62fe14(x的地址)。 * y给出x的地址，即0x62fe14。执行y [0] =(char *)0x62fe14替换该值，但没有个人用途。如果在0x62fe14中进行任何更改，不仅会影响y [0]，而且还会更改a的地址，因为y的地址为x，该地址存储在第0位。
Q7. What is the output of this program?
#include
struct A {
int a1;
struct B {
int a1;
} A1;
} B1;
int main(void)
{
B1.a1 = 10;
B1.A1.a1 = 11;
int* x = &B1.a1;
int* y = &B1.A1.a1;
x = y;
char** z = (char**)&x;
*z[0] = x[0];
printf("%x", **z);
}
A. a
B. b
C. ab
D. No output回答：
B. b解释：
将x初始化为y将更改x的地址。基本上，谋杀B1.a1的地址并将x中的值替换为y中的值为11。* z [0] = x [0]是没有用的，因为它已经包含x的地址。打印z的十六进制值得到b(11的十六进制)。
Q8. What is printed?
#include
int main(void)
{
int a = (int)0b01001011;
int* b = &a;
int n[10] = { (int)0b010110, 17,
-4, -13, 19, -19,
10, (int)0b11110110 };
for (int i = 0; i < 9; i++) {
printf("%c", b[0]);
b[0] += n[i];
}
}
A. Karnataka
B. karnataka
C. Kerala
D. kerala回答：
A. Karnataka解释：
01001011的整数值为75，ASCII值“ K”。 010110的整数是22，而11110110的整数是-10。由于不超过32位(4字节)，因此b [0]包含整数。将n的每个值相加，替换b [0]中的值，从而打印每个字符(由于格式说明符)。
Q9. How does the output look like in this program?
#include
int main(void)
{
// Use this as a reference:
// 1011001100110011
// 1111000011110011
// 0111000011010011
// 0011000000001001;
int a = (int)0b1011001100110011111100001111001101110000110100110011000000001001;
short int* b = (short int*)&a;
printf("%d %d %d %d", b[3], b[2], b[1], b[0]);
}
A. decimal value of 1011001100110011 decimal value of 1111000011110011 decimal value of 0111000011010011 decimal value of 0011000000001001
B. Junk value Junk value Junk value decimal value of 0011000000001001
C. Junk value Junk value Junk value Junk value
D. Junk value Junk value decimal value of 0111000011010011 decimal value of 0011000000001001回答：
D. Junk value Junk value decimal value of 0111000011010011 decimal value of 0011000000001001解释：
short int的大小为2个字节，等于16位。在这64位中，a仅占用32位。并且，b [0]存储2个字节，b [1]存储2个字节。这就是为什么要获得带有两个垃圾值和两个十进制值的输出的原因。
Q10. What is the output of this program?
#include
union A {
int a;
long long int b;
} A1;
int main(void)
{
A1.a = 10;
A1.b = 100;
char* a = (char*)&A1;
printf("%x %x %x %x %x %x %x %x",
a[7], a[6], a[5],
a[4], a[3], a[2],
a[1], a[0]);
}
A. 0 0 0 0 0 0 0 64
B. 0 0 0 0 0 0 0 0
C. All junk values
D. 0 0 0 0 0 0 0 A回答：
A. 0 0 0 0 0 0 0 64解释：
此联合的大小为8字节或64位。联盟中的最新值是100，它将替换最初拥有10的第一个头寸。十六进制值100为64，导致此输出。 0个字节为7个字节，64个字节为1个字节。