12. ¿Cuál es el resultado del siguiente código y por qué?
vacío foo (vacío)
{
int sin signo a = 6;
int b = -20;
(a+b > 6) pone("> 6") : pone("<= 6");
}
Esta pregunta prueba si comprende los principios de la conversión automática de enteros en C, y descubrí que algunos desarrolladores entienden muy poco de estas cosas. De todos modos, la respuesta al problema de los enteros sin signo es que la salida es ">6". El motivo es que todos los operandos se convierten automáticamente en tipos sin signo cuando hay tipos con y sin signo en la expresión. Entonces, -20 se convierte en un entero positivo muy grande, por lo que la expresión se evalúa como mayor que 6. Esto es muy importante para los sistemas integrados donde los tipos de datos sin firmar deben usarse con frecuencia. Si responde mal esta pregunta, está a punto de no conseguir el trabajo.
13. Evalúe el siguiente fragmento de código:
int sin signo cero = 0;
compzero int sin signo = 0xFFFF;
Para un procesador cuyo tipo int no sea de 16 bits, el código anterior es incorrecto. debe escribirse de la siguiente manera:
sin signo int compzero = ~0;
Esta pregunta realmente puede revelar si el candidato comprende la importancia del tamaño de palabra del procesador. Según mi experiencia, los buenos programadores integrados entienden los detalles del hardware y sus limitaciones con mucha precisión, mientras que los programas de PC a menudo tratan el hardware como una molestia inevitable.
En esta etapa, los candidatos están completamente desanimados o confiados en que tendrán éxito. Si está claro que el examinado no es muy bueno, entonces la prueba termina aquí. Pero si está claro que el examinado lo está haciendo bien, entonces tiro las siguientes preguntas adicionales, que son más difíciles, y creo que solo los muy buenos examinados pueden hacerlo bien. Al hacer estas preguntas, quiero ver más acerca de cómo los examinados manejan las preguntas, no las respuestas. No importa qué, solo lo tratas como entretenimiento...
Asignación de memoria dinámica
14. Aunque no son tan comunes como las computadoras no integradas, los sistemas integrados todavía tienen el proceso de asignación dinámica de memoria desde el montón. Entonces, ¿cuáles son los posibles problemas de la asignación dinámica de memoria en un sistema integrado?
Aquí, espero que los candidatos mencionen la fragmentación de la memoria, los problemas de recolección de basura, el tiempo de persistencia variable, etc. Este tema ha sido tratado extensamente en las revistas ESP (principalmente por PJ Plauger, cuyas explicaciones superan con creces todo lo que puedo mencionar aquí), ¡así que vuelva a consultar esas revistas! Después de hacer que el candidato tenga una falsa sensación de seguridad, se me ocurre este pequeño programa: ¿Cuál es el resultado del siguiente fragmento de código y por qué?
carácter *ptr;
if ((ptr = (char *)malloc(0)) == NULL)
puts("Obtuve un puntero nulo");
demás
puts("Obtuve un puntero valido");
Esta es una pregunta interesante. Solo pensé en este problema recientemente después de que uno de mis colegas pasara inadvertidamente un valor de 0 a la función malloc y obtuviera un puntero válido. Este es el código anterior, que muestra "Tengo un puntero válido". Uso esto para iniciar una discusión sobre si el entrevistado cree que la rutina de la biblioteca está haciendo lo correcto. Obtener la respuesta correcta es importante, pero el enfoque del problema y su justificación para tomar una decisión es aún más importante.
definición de tipo
15. Typedef se usa con frecuencia en lenguaje C para declarar un sinónimo de un tipo de datos existente. También puedes hacer algo similar con un preprocesador. Por ejemplo, considere el siguiente ejemplo:
#define estructuras dPS *
estructura typedef s * tPS;
La intención de los dos casos anteriores es definir dPS y tPS como un puntero a la estructura s. ¿Qué método es mejor? (si lo hay) ¿por qué?
Esta es una pregunta muy delicada, y cualquier persona que responda correctamente (por una buena razón) debe ser felicitada. La respuesta es: typedefs son mejores. Considere el siguiente ejemplo:
dPSp1,p2;
tPS p3, p4;
El primero se expande a
estructura s * p1, p2;
El código anterior define p1 como un puntero a una estructura y p2 como una estructura real, que puede no ser lo que desea. El segundo ejemplo define correctamente los dos punteros p3 y p4.
gramática oscura
16. El lenguaje C admite algunas construcciones sorprendentes, ¿es legal la siguiente construcción y, de ser así, qué hace?
int a = 5, b = 7, c;
c = a+++b;
Esta pregunta servirá como un final feliz para este cuestionario. Lo creas o no, el ejemplo anterior es perfectamente gramatical. La pregunta es ¿cómo lo maneja el compilador? Los autores de compiladores de bajo nivel realmente argumentarán este problema, de acuerdo con el principio del mejor procesamiento, el compilador debería poder manejar todos los usos legales posibles. Por lo tanto, el código anterior se procesa como:
c = a++ + b;
Por lo tanto, este código ejecuta a = 6, b = 7, c = 12.
Si sabe la respuesta, o adivinó la respuesta correcta, bien hecho. Si no sabes la respuesta, tampoco lo tomo como una pregunta. Lo que mejor encuentro sobre esta pregunta es: es un buen tema sobre el estilo de codificación, la legibilidad del código, la modificabilidad del código
¿Qué se imprimirá?
principal()
{
char *p1=“nombre”;
carácter *p2;
p2=(caracter*)malloc(20);
conjunto de memoria (p2, 0, 20);
mientras(*p2++ = *p1++);
printf(“%sn”,p2);
}
Respuesta: cadena vacía.
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
enterox=20,y=35;
x=y++ + x++;
y= ++y + ++x;
printf(“%d%dn”,x,y);
}
Respuesta: 5794
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
intx=5;
printf(“%d,%d,%dn”,x,x< <2,x>>2);
}
Respuesta: 5,20,1
Lo que se imprimirá como resultado de la siguiente operación:
#define intercambio(a,b) a=a+b;b=ab;a=ab;
vacío principal()
{
entero x=5, y=10;
intercambiar (x,y);
printf(“%d %dn”,x,y);
intercambiar2(x,y);
printf(“%d %dn”,x,y);
}
int swap2(int a, int b)
{
temperatura interna;
temperatura=a;
b=a;
a = temperatura;
devolver 0;
}
Respuesta: 10, 5
10, 5
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
char *ptr = "Sistemas Cisco";
*ptr++; printf(“%sn”,ptr);
ptr++;
printf(“%sn”,ptr);
}
Respuesta:Cisco Systems
sistemas isco
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
char s1[]=“Cisco”;
char s2[]= “sistemas”;
imprimir(“%s”,s1);
}
Respuesta: Cisco
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
carácter *p1;
carácter *p2;
p1=(caracter *)malloc(25);
p2=(caracter *)malloc(25);
strcpy(p1,"Cisco");
strcpy(p2,“sistemas”);
cadena(p1,p2);
imprimirf(“%s”,p1);
}
Respuesta: Ciscosystems
La siguiente variable está disponible en file1.c, ¿quién puede acceder a ella?:
promedio int estático;
Respuesta: todas las funciones en el archivo1.c pueden acceder a la variable.
¿Cuál será el resultado del siguiente código?
#define TRUE 0 // algún código
mientras (VERDADERO)
{
// algún código
}
Respuesta: Esto no entrará en el bucle ya que TRUE se define como 0.
Lo que se imprimirá como resultado de la siguiente operación:
intx;
int modificarvalor()
{
retorno(x+=10);
}
valor de cambio int (int x)
{
retorno(x+=1);
}
vacío principal()
{
enterox=10;
x++;
cambiarvalor(x);
x++;
modificarvalor();
printf("Primera salida:%dn",x);
x++;
cambiarvalor(x);
printf("Segunda salida:%dn",x);
modificarvalor();
printf("Tercera salida:%dn",x);
}
Respuesta: 12 , 13 , 13
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
entero x=10, y=15;
x = x++;
y = ++y;
printf(“%d %dn”,x,y);
}
Respuesta: 11, 16
Lo que se imprimirá como resultado de la siguiente operación:
principal()
{
int a=0;
si(a==0)
printf(“Cisco Systemsn”);
printf(“Cisco Systemsn”);
}
Respuesta: Se imprimirán dos líneas con "Cisco Systems".