Q1. ¿La salida de este código es verdadera o falsa?
#include <stdio.h>
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
Responder:
A. True
Explicación:
La forma binaria de 20 es 10100 que se almacena en la memoria. Dado que es de tipo int, se asignan cuatro bytes y 10100 se almacena en la posición 0. Accedemos a los elementos de un arreglo de izquierda a derecha. Pero, en la memoria, se accede a los bits de memoria (no a todos los arreglos) de derecha a izquierda. El valor ASCII se almacena en otro bloque de 1 byte que tiene solo una posición 0. Cuando igualamos y[0] a z[0], estamos sobrescribiendo el valor de b indirectamente. Esto hace que ambos punteros sean iguales.
Q2. ¿Cuál es la salida de este programa?
#include <stdio.h>
#include <stdlib.h>
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
Responder:
C. ABCDEFGHIJKLMNOPQRSTUVWXYZ
Explicación:
el espacio asignado para un carácter es solo 1 byte u 8 bits. y se asigna durante el tiempo de ejecución. Contiene la dirección de x. Ahora, podemos indexar la ubicación de memoria de x. Y, cualquier cambio en y se refleja en x también. Cuando se ejecuta y[0]+=1, en cada ciclo, el último bit en ese 1 byte de datos se incrementa en 1 como:
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.
Nota: Intentar indexar y[1] y cualquier otra ubicación genera un valor basura.
Q3. ¿Qué se imprime al final de este programa?
#include <stdio.h>
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
Responder:
D. 10 20
Explicación:
Aquí, solo se cambia el bit 0 de a y b, lo que lleva al cambio en los valores.
Q4. ¿Es el valor de a al final del programa el mismo que al principio?
#include <stdio.h>
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
Responder:
A. Yes
Explicación:
El valor binario de 100 es 01100100, 132 es 10000100 y 3 es 00000011. Ahora esto es lo que sucede
b[3] b[2] b[1] b[0] 00000000 00000000 00000000 01100100 +00000000 00000000 00000011 10000100 ------------------------------------ 00000000 00000000 00000011 11101000 This gives 1000.
Ahora nuevamente los valores son reemplazados. 232-32 es 200, y esto dividido por 2 da 100, que se reemplaza en b[0]. Entonces, 11101000 se convierte en 01100100. b[1]*=0 hace que los 8 bits de b[1]=0. Esto da la salida de a como 100, que era la misma que al principio.
P5. ¿Qué le pasa a este programa?
#include <stdio.h>
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
Responder:
B. Segmentation Fault
Explicación:
el programa fallaría porque y apunta a 0x100, que es la dirección de algún otro programa en ejecución.
P6. ¿Cuál es el resultado de este programa (Considere la dirección de x como 62fe14)?
#include <stdio.h>
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
Responder:
D. 0x62fe14 0x62fe14
Explicación:
y[0] ya contiene 0x62fe14 (dirección de x). Y *y da la dirección de x, es decir, 0x62fe14. Ejecutar y[0]=(char *)0x62fe14 reemplaza el valor pero no es de uso personal. Si cambia algo en 0x62fe14, no solo afecta a y[0], sino que también cambia la dirección de a, ya que y tiene la dirección de x, que se almacena en la posición 0.
P7. ¿Cuál es la salida de este programa?
#include <stdio.h>
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
Responder:
B. b
Explicación:
La inicialización de x a y cambia la dirección de x. Básicamente, eliminar la dirección de B1.a1 y reemplazar el valor de x con el valor de y, que es 11. *z[0] = x[0] no sirve de nada porque ya contiene la dirección de x. Imprimir el valor hexadecimal de z da b (hexadecimal de 11).
P8. ¿Qué se imprime?
#include <stdio.h>
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
Responder:
A. Karnataka
Explicación:
El valor entero de 01001011 es 75, el valor ASCII de ‘K’. El valor entero de 010110 es 22 y el de 11110110 es -10. Dado que no se exceden los 32 bits (4 bytes), b[0] contiene el número completo. Al agregar cada valor de n, se reemplaza el valor en b[0], lo que lleva a imprimir cada carácter (debido al especificador de formato).
P9. ¿Cómo se ve la salida en este programa?
#include <stdio.h>
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
Responder:
D. Junk value Junk value decimal value of 0111000011010011 decimal value of 0011000000001001
Explicación: El
tamaño del int corto es de 2 bytes, lo que equivale a 16 bits. a toma solo 32 bits de estos 64 bits. Y, b[0] almacena 2 bytes y b[1] almacena 2 bytes. Esa es la razón por la que obtiene la salida con dos valores basura y dos valores decimales.
P10. ¿Cuál es la salida de este programa?
#include <stdio.h>
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
Responder:
A. 0 0 0 0 0 0 0 64
Explicación: El
tamaño de esta unión es de 8 bytes o 64 bits. El último valor puesto en la unión es 100, que reemplaza la primera posición que tenía 10 inicialmente. El valor hexadecimal de 100 es 64, lo que lleva a esta salida. 7 bytes como 0 y 1 byte como 64.
Publicación traducida automáticamente
Artículo escrito por anurag_r_simha y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA