1. La programación requiere la entrada de números enteros A y b. Si a2 b2 es mayor que 100, se generará un número con a2 b2 mayor que 100 dígitos; Se generarán los dos números.
# incluir ltstdio.h gt
int main()
{
int a, b;
printf("Ingrese dos números: ");
scanf("d d ", amp one, ampb
if((a * a b * b) gt; = 100); )
printf("\n d ", (a * a b * b)/100
Otros
printf("\n d ", a b ) ;
getch();
}
2. Intente programar para determinar si los enteros positivos de entrada son todos múltiplos de 5 y 7. En caso afirmativo, la salida es; de lo contrario, el número de salida
# incluye ltstdio.h gt
int main()
{
int a;
printf("Ingrese un número: ");
scanf("d ", ampa
if(a 5 = =); 0 amp; ampa7==0)
printf(" si ");
Otros
printf(" no ");
getch();
}
Aguja
1. Escriba un programa para asignar la cadena de la computadora a una matriz de caracteres y luego inicie cada carácter desde allí. primera letra Genera una cadena de vez en cuando. Complételo con sugerencias.
# include ltstdio.h gt
int main()
{
char string[]= "Computadora";
p>
char * p = cadena
mientras(*p)
{
printf("c ", * p );
p;
p
}
obtener(); >
2, ingrese una cadena y luego agregue un espacio entre cada letra en la cadena; use un puntero para completar.
#incluye ltstdio.h gt
#incluye ltstdio.h gt. H gt
# incluye ltSTDLIB.
H gt
#Definir hasta 100
char * copyString
copia vacía(char *, char *);
inserción vacía ( char *);
int main()
{
char * cadena
cadena = (char *)malloc(max * sizeof(char));
scanf("s ", cadena);
Insert(string
printf("s ", cadena de caracteres); );
getch();
Devuelve 0
}
Copia no válida (char * c, char * s)
{
mientras(*s!='\0')
{
*c = *s;
s;
c;
}
*c='\0
}
Inserción nula (carácter)
{
copiar cadena =(char *)malloc(2 * max * sizeof(char));
copiar(copyString, s);
while(*copyString!='\0')
{
* s = * copyString
s ;
copiar cadena ;
* s = ""
s ;
}
* s = ' \ 0
}
1. Elección:
1. Dé la siguiente definición:
char acX[]= "abcdefg ";
char acY[ ]= {'a', 'b', 'c', 'd', 'e', 'f', 'g' };
La afirmación correcta es ()
a) La matriz acX y la matriz acY son equivalentes b) La matriz acX y la matriz acY tienen la misma longitud;
c) La longitud de la matriz acX es mayor que la longitud de la matriz acY d) La longitud de la matriz acX es menor que la longitud de la matriz acY;
Respuesta: c
2.
Ejemplo de vacío (char acHello[])
{
printf ("d ",sizeof(acHello));
Retorno;
}
void main()
{
char acHello[] = "Hola";
Ejemplo (Accello); //El nombre de la matriz se utiliza como parámetro y se pasa la dirección. Una dirección ocupa cuatro bytes.
Regreso;
}
La salida es
Incierta
Respuesta: Respuesta
3. Existe el siguiente segmento de programa
char Acar[]= "ABCDE";
char * pcPtr
for(pcPtr = acArr; pcPtr ltacArr 5; pcPtr )
{
printf("s\n ", pcPtr);
}
Regresar;
El resultado de salida es ()
A) ABCD B) A C) E D) ABCDE
BCDE
CDE
D B DE
E A'E
Respuesta: d
4. En una interrupción, el semáforo no se puede adquirir sincrónicamente, pero se puede liberar.
A. Verdadero b. Incorrecto
Respuesta: Respuesta
5. ¿Cuál de las siguientes afirmaciones es incorrecta ()
a ) Las variables con el mismo nombre se pueden usar en diferentes funciones
b) Los parámetros formales en las funciones son variables locales.
c) Las variables definidas en una función sólo son válidas dentro del alcance de la función.
d) Las variables definidas por sentencias compuestas dentro de una función son válidas dentro del alcance de la función (las sentencias compuestas se refieren al código formado por pares de corchetes dentro de la función).
Respuesta: d
6. Se proporciona la siguiente definición:
Unsigned long pulArray[] = {6, 7, 8, 9, 10 };
Unsigned long * pulPtr
El resultado de salida del siguiente segmento del programa es ()
pulPtr = pulArray
*(pulPtr 2 ) = 2;
printf ("d, d\n ", *pulPtr, *(pulPtr 2));
a)810 B)6.8 C)7.9D) 610
Respuesta: d
7. Hay varias afirmaciones a la hora de definir una estructura. Indique la correcta (múltiples opciones): _ _ _ _ _ _ _
a Cada parte de la estructura debe estar alineada en cuatro bytes;
b, la longitud total. de la estructura se alinea preferiblemente en cuatro bytes;
c. El almacenamiento de miembros en la estructura no considera la alineación de bytes;
Respuesta: a, b
p>8.void ejemplo()
{
int I;
char AC new[20];
for( I = 0;ilt10;i)
{
AC nuevo[I]= ' 0 ';
}
printf( "d\n ",strlen(AC new));
Regresar;
}
La salida es ()
A 0 B 10 C 11 D No estoy seguro.
Respuesta: d
9. El tipo de datos de c en el interruptor (c) puede ser char, long, float, unsigned, bool. ()
A. Verdadero b. Incorrecto
Respuesta: b
10. De forma predeterminada, el orden de bytes transmitidos en la red es grande. Si el host es pequeño, el orden de bytes debe convertirse al comunicarse en la red; si el host es big endian, por razones de coherencia y portabilidad del programa, es mejor agregar el orden de bytes al programa Operación de conversión (no). operación).
A. Verdadero b. Incorrecto
Respuesta: Respuesta
11. num
Nombre del personaje[10];
int age
};
Fondos no válidos (estructura stu *p)
{
printf("s\n ", (*p). Nombre
Retorno
}
<); p>void main(){
estructura estudiantes[3]= { { 9801, "张", 20},
{9802, "王", 19},
{9803, "Zhao", 18 } };
Diversión (estudiante 2);
Regreso;
p>
}
El resultado de salida es ()
a) Zhang B) Zhao C) Wang D) 18
Respuesta: b
12. Después de ejecutar el siguiente programa, el resultado de salida es ().
void main()
{
char * szStr = " abcde
sztr = 2;
printf("lu \n ", sztr);
Return;
}
El valor del código ASCLL de un carácter cde B
C "abcde" es un error en la dirección D donde se encuentra el carácter C
Respuesta: c
13, existe el siguiente proceso. >
#.incluye ltstdio.h gt
void main()
{
alianza
{
int k;
char I[2];
}*s,
s = ampa; s- gt; I[ 0]= 0x 39;
s- gt; I[1]= 0x 38;
printf("x\n ", a . k) ;
}
El resultado de salida es ()
A) 3839 B) 3938 C) 380039 D) Impredecible
Respuesta: d
14. Las variables globales pueden estar en varios archivos .c
A. Falso
Respuesta: b
15.void.Ejemplo()
{
int I;
char acNew[20] = {0, 0, 0, 0, 0, 0 , 0, 0 ,0,0,0,0,0,0,0,0,0,0,0,0,0};
for(I = 0;ilt10;i)
{
AC nuevo[I]= ' 0 ';
}
printf("d\n ",strlen(AC new)) ;
Regresar;
}
La salida es:
A 0 B 10 C 11 D No estoy seguro.
Respuesta: b
16. Las siguientes definiciones son correctas (múltiples opciones): ()
a: char * pcPtr = "ABCD";
p>
b: carácter PC[4]= "ABCD";
c: carácter PC[]= "ABCD";
d: carácter PC[]= ' ABCD ';
E: char pc[] = {'a', 'b', 'c', 'd', '\0'};
f: char PC[]= ' a ' ' b ' ' c ' ' d ';
Respuesta: Ace
17. registrar variables y otras variables especiales Excepto) la memoria está en la memoria de la pila, por lo que al definir variables dentro de la función, la pila no debe desbordarse. Si la variable temporal
ocupa un espacio grande, debe utilizar el método de asignación de memoria para que la memoria apuntada por esta variable esté en la memoria del montón.
A. Verdadero b. Incorrecto
Respuesta:
18. Las variables locales pueden tener el mismo nombre que las variables globales y no habrá errores durante compilación, pero puede usar accidentalmente la variable incorrecta, por lo que cuando cronometre las variables locales, no tenga el mismo nombre que la variable global.
A. Verdadero b. Incorrecto
Respuesta: Respuesta
19. Se proporcionan las siguientes definiciones de macro:
#Definición N 3
#define Y(n) ((N 1)*n) /*El uso de esta definición está estrictamente prohibido en las especificaciones de programación*/
Luego ejecuta la sentencia: z = 2 *(N Y (5 1)); Después de eso, el valor de z es ()
a) Incorrecto B) 42 C) 48 D) 54
Respuesta: c
20.int *(* ptr)();
La siguiente afirmación correcta es ()
A) ptr es una variable puntero que apunta al número de grupos unidimensionales.
B) ptr es una variable puntero que apunta a datos int.
ptr es un puntero que apunta a una función que devuelve datos int.
D) ptr es un puntero a una función y el valor de retorno de la función es un puntero a datos int.
Respuesta: d
El orden de la memoria 21.0x12345678 es _ _ _ _ _ en BigEndian y _ _ _ _ _ en LittleEndian.
(Las respuestas aumentan de izquierda a derecha.)
12 34 56 78
C.78 56 34 12
La respuesta es : Corriente alterna
2. Completa los espacios en blanco:
1.
Etiqueta de estructura a
{
Carácter sin firmar ucId: 1;
Carácter sin firmar UCP ara 0:
Carácter sin firmar ucState: 6;
Cola UC de carácter sin firmar: 4;
Carácter UCAvail sin firmar
Cola UC de carácter sin firmar 2: 4;
Longitud sin firmar ulData
} AAA_S;
P: ¿Cuánto espacio ocupa AAA_S cuando la alineación de bytes es 1 y 4 respectivamente?
Respuesta: 9 12
2.prueba de etiqueta de estructura typedef
{
UCHAR ucFlag
ULONG ulLen
} TEST_S;
TEST_S TEST[10];
Alineación de cuatro bytes: sizeof (test_s) = _ _ _ _ , sizeof(test)_ _ _ _ _ _ _.
Respuesta: 8 80
Tres
char a chello[]= " hola \ 0 mundo ";
char AC new[ 15]= { 0 };
strcpy(acNew, un chello);
strlen(acNew) = ____
sizeof(acHello) = _____
Respuesta: 5 12
4.#pragma pack(4)/*Opción de compilación, que indica alineación de 4 bytes*/
int main(int argc, char * argv[])
{
Prueba de etiqueta de estructura 1
{
Corto a;
char d;
Largo b;
Largo c;
};
Prueba de calificación estructural 2
{
Larga b;
Corta c;
char d;
Larga a;
};
Prueba de marcado de estructura 3
{
C corta;
B larga;
char d;
p>
Largo a;
};
struct tagtest 1 STT 1;
struct tagTest2 stT2
struct tagTest3 stT3
printf("d d d ", sizeof(stT1), sizeof(stT2), sizeof(STT 3));
Return 0; p>}
}
p>
#pragma pack()(opciones de fin de compilación)
¿Cuál es el resultado? _ _ _ _ _ _ _
Respuesta: 12 12 16.
5. Enumeración ENUM_A
{
X1,
Y1,
Z1 = 5,
Y1. p>
A1,
B1
};
ENUM ENUM _ A enumA = y 1;
ENUM ENUM _ A ENUM b = b 1;
Disculpe, enumA = _ _ _ _enum b = _ _ _ _ _ _ _;
Respuesta: 1 7
6.La salida del siguiente programa es _ _ _ _ _ _.
# include ltstdio.h gt
int fun(int x, int y)
{
static int m = 0; ocho
estático int I = 2; tres
I = m 12
m = I x y;
return m;
}
void main()
{
int j = 4
int m = 1; ;
int k;
k = divertido(j,m);
printf("d ",k);
k=diversión(j, m);
printf("d\n ", k
Retorno
}
7. La salida del siguiente programa es _ _ _ _ _ _ _ _ _
#Define CIR(r) r*r /*Por favor pague atención a esta definición Defecto, no se permite definir */
void main()
{
int a = 1; int b = 2 ;
int t;
t = CIR(a b);
printf("d\n ",t);
Retorno;
}
Respuesta: 5
8. En VRP, se implementa una función similar a strncpy, y su definición es la siguiente. :
#Definir carácter
#Definir tipo largo sin firmar ULONG
#Definir vacío
#definir MACRO_COPYWORLDLENGTH 4
CHAR *VOS_strncpy (CHAR *pcDest, const CHAR *szSrc, ULONG ulLength)
{
CHAR * pcPoint = pcDest
if((NULL = = SZ src)| (NULL = = destino de PC)))
{
Devuelve NULL
}
Y ( ulLength amp amp(*pcPoint = *szSrc))/*Aquí se utiliza el método de asignación de declaración de juicio (*pcPoint = *szSrc Se recomienda no utilizar */
{
<). p>Punto PC;SZ src;
ulLength-;
}
if (! ulLength)
{
* pcPoint = ' \ 0
}
Devolver pcDest
}
Controlador no válido (no válido)
{
CHAR sztrbuf[]= " 1234567890 ";
CHAR szstrbuf 1[]= " 1234567890 " ;
CHAR *szHelloWorld = "¡Hola mundo!";
strncpy(szStrBuf, szHelloWorld, MACRO _ COPYWORLDLENGTH
VOS_strncpy(szStrBuf1, szHelloWorld, MACRO); _ COPYWORLDLENGTH);
pri
ntf("s s ", szStrBuf, szStrBuf 1);
}
La salida del programa es _ _ _ _ _ _ _ _ _
Respuesta : Hell567890 Infierno
9.
char a chello[]= " hola \ 0 mundo ";
char AC new[15]= { 0 };
p>
memcpy(acNuevo, acHola, 12);
strlen(acNuevo) = ____
tamaño de(acHola) = ____
Respuesta: 5 12
10.encabezado de estructura typedef
{
UCHAR AUC src[6];
ULONG ulType
} HEAD_S;
Al forzar la alineación de un solo byte, especifique sizeof(head_s)=_ _ _ _ _ _;
Al forzar la entrada binaria en el caso de alineación, especifique sizeof(head _ s)= _ _ _ _ _ _ _;
Si se fuerza una alineación de cuatro bytes, especifique sizeof(head _ s)= _ _ _ _ _ _ _;
Respuesta: 10 10 12
Etiqueta UnitedAAAA
{
Estructura
{
char ucPrimero
corto usSegundo
char ucTercero
}Mitad;
Longli;
}Número;
Etiqueta de estructura BBBBB
{
char ucPrimero
Us cortoSegundo
char ucTercero
Abreviado
}Mitad;
Etiqueta de estructura CCCC
{
Estructura
p>{
char ucPrimero
corto usSegundo
char ucTercero
}mitad;
Long Li;
};
Cuando la alineación de bytes es 1, sizeof(union tagAAAA), sizeof(struct tagBBBBB) y sizeof(struct tagCCCC) son _ _ _ _ _ _ _ _ _ _.
Cuando la alineación de bytes es 4, sizeof(union tagAAAA), sizeof(struct tagBBBBB) y sizeof(struct tagCCCC) son _ _ _ _ _ _ _ _ _.
Respuesta: 4 6 8
8 8 12
12. Etiqueta de estructura
{
char cB
sC corto;
char CD
tirón largo;
} * pAbc
pAbc = 0x 100000 ;
Entonces PABC 0x 100 = 0x _ _ _ _ _ _ _ _ _;(ULONG)pAbc 0x 100 = 0x _ _ _ _ _ _ _ _;(ULONG *)pAbc 0x 100 = 0x _ _ _ _ _ _ _ _ _;(char *)pAbc 0x 100 = 0x _ _ _ _ _ _ _ _ _;
Respuesta: 100 c 00100100100400100100.
13. Tipo de entero largo sin signo FUNC_C (operación de entero largo sin signo)
{
Tipo de entero largo sin signo ul resultado = 0;
p>
Cambiar (acción u)
{
Operación de caso_A:
{
ul resultado = 1; /p>
Pausa;
}
Caso operación_B:
{
ul resultado = 1;
}
Valor predeterminado:
{
ul resultado = 1;
}
}
printf( "ulResult = u ",ul resultado);
Devolver ulResult
}
Cuando la entrada es ACTION_B Cuando, el resultado de salida es: resultado UL = _ _ _ _ _ _ _;
Respuesta: 2 (porque esta rama no tiene punto de interrupción)
14. la prueba de funcionamiento, el resultado impreso es _ _ _ _.
G_ul largo sin firmar global = 0;
void GlobalInit(ulArg largo sin firmar)
{
ulArg = 0x 01;
Retorno;
}
Prueba no válida()
{
init global (g _ ul global);
printf("lu ", g _ ul global
Retorno
}
Respuesta: 0
15. El resultado de salida del siguiente programa es _ _ _ _ _ _ _ _ _
int x = 3;
void incr();
void main()
{ int I;
for(I = 1;iltx;i)
{
incre();
}
Retorno;
}
Incremento no válido()
p>{
Estático int x = 1;
x * = (x 1
printf("d ", x
}
Respuesta: 2 6
16. El resultado de salida del siguiente programa es _ _ _ _ _ _ _ _ _
#pragma pack(4)/*Alineación de cuatro bytes*/
int main(int argc, char* argv[])
{
Carácter sin firmar puc[4];
Etiqueta de estructura
{
Carácter sin firmar ucpim 1;
Datos UC de carácter sin firmar 0:1;
Datos UC de caracteres sin firmar 1:2;
Datos UC de caracteres sin firmar 2:3;
} * pstPimData
pstPimData =(estructura etiqueta PIM *)puc;
memset(puc, 0, 4);
pstPimData- gt; pstPimData-gt; datos UC 0 = 2;
pstPimData-gt; datos UC 1 = 3;
datos UC 2 = 4; >printf("02X 02X 02X 02X\n ", puc[0], puc[1], puc[2], puc[3]);
Devuelve 0;
}
#pragma pack()/*Restaurar alineación predeterminada*/
Respuesta: 01 26 00 00
17 .
char * Color de PC = " azul 1 ";
char acColor[] = " azul 1 "
strlen(pcColor) = ____
strlen(acColor) = ____
tamaño de(pcColor) = ____
tamaño de(acColor) = ____
Respuesta: 5 5 4 6
18.
char str[]= " \ \ \ 0 ";
char * p;
= str
int n = 1000;
Por favor, calcule
sizeof (str) = _________
sizeof (p) = ______________
tamaño de ( n ) = ______________
Respuesta: 3 4 4
19.UCHAR * pucCharArray[10][10];
typedef union unRec
{
ULONG ulIndex
USHORT us level[6];
UCHAR ucPos
} REC_S;
REC_S stMax, *pstMax
Alineación de cuatro bytes: sizeof(pucCharArray) = __matriz de punteros, la dirección de cada puntero es de 4 bytes_ _ _ _, Sizeof ( stmax) = _ _ _ _, Tamaño de (pstmax) = _ _ _ _ _ _ _ _, Tamaño de (* pstmax) = _ _ _ _ _ _ _.
Respuesta: 400 12 4 12
20.typedef union unHead
{
UCHAR AUC src[6];
Contenido de la marca de estructura
{
UCHAR UC flag[3];
ULONG ulNext
} contenido;
p>
} HEAD _ S;
32CPU, entorno de compilación VC:
En el caso de forzar la alineación de un solo byte, especifique sizeof(head _ s)= _ _ _ _ _ _ _;
En el caso de alineación binaria forzada, especifique sizeof(head _ s)= _ _ _ _ _ _ _;
Si se fuerza la alineación de cuatro bytes, especifique sizeof(head _ s)= _ _ _ _ _ _ _;
Respuesta: 7 8 8
21.
UCHAR * pszTest = " hola
UCHAR AUC test[]= " hola ";
Disculpe, sizeof (psztest) = _ _ _, sizeof (* psztest ) = _ _ _ _, sizeof (auctionest) = _ _ _
Respuesta: 4 1 6
22. >
lNum largo
char * pcName
SFecha corta
char cHa[2];
SBa corta[6] ;
} * p;
p = 0x 100000;
p 0x1 = 0x___
(Entero largo sin signo)p 0x1 = 0x______
(Unsigned long *)p 0x1 = 0x______
(char *)p 0x1 = 0x______
Respuesta: 10001810001 100004 10001.
23. En el caso de alineación de 4 bytes:
estructura typedef tagRec
{
龙la 1;
char cA2
char cA3
龙lA4
龙lA5
} REC_S;
void main(int argc, char *argv[])
{
REC _ S stMax
printf("\r\n sizeof(stMax)= d ",sizeof(stMax));
Return;
}
El resultado de salida es:
sizeof(stMax) = ___
Respuesta: 16
24.void main()
{
UlA largo sin firmar = 0x 11000000
;printf("\r\nx", *(carácter sin firmar *) amp; ulA
Retorno
}
El resultado de salida; es:
Respuesta: 0
En tercer lugar, señale el único error en el siguiente proceso que hace que el resultado esperado falle (independientemente de los errores de especificación de programación)
1. El siguiente programa se utiliza para generar la cadena ingresada por el usuario. Por favor señale el problema.
#Definición OK 0
#Error de definición 1
#Error de definición (-1)
#Tamaño del búfer de definición 256< / p>
int GetMemory(char **ppszBuf, int num)
{
if( NULL == ppszBuf)
{
Aserción(0);
Error de retorno;
}
* ppszBuf =(char *)malloc(num);
if(NULL == *ppszBuf)
{
Devolver error;
}
Devolver OK;
}
Prueba no válida (no válida)
{
char * pcStr = NULL
if(OK == GetMemory ( amp; pcStr, BUFFER_SIZE))
{
scanf("s ", pcStr); /* Se supone que BUFFER_SIZE es lo suficientemente grande como para evitar cruzar el límite*/
printf(pcStr);
Gratis(pcStr);
}
Devolver;
}
Respuesta: Imprima en forma de printf ("s", str); de lo contrario, ingrese en forma de s, d, etc. Puede conducir a lo desconocido.
2. Esta función puede imprimir la dirección IP de 32 bits (secuencia de host) como una cadena.
Encuentre el error en el código:
char *IpAddr2Str (unsigned long ulIpAddr)
{
char szIpAddr[32];
(void)VOS_sprintf(szIpAddr," d.d.d.d",ulIpAddr gt gt24,
(ulIpAddr gt gt16); 0xff, (ulIpAddr gt gt8) amp; 0xff, ulIpAddr amp0x ff);
p >Devuelve szIpAddr
}
Respuesta: Las variables locales de la función se almacenan en la pila. Esta función devuelve la dirección en la pila y el contenido de la pila no está disponible después de que sale la función.
3. El siguiente programa se utiliza para generar "Bienvenido a casa". Señale el error:
Prueba no válida(inválida)
{
char PC array[12];
strcpy(pcArray ," Bienvenido a casa");
printf("s!", matriz de PC);
Regresar;
}
Respuesta : La matriz está fuera de los límites.
4. El siguiente programa se utiliza para devolver una cadena "azul", indique el error:
char *GetBLUE(void)
{
char * pcColor
char * pcNewColor
pcColor = " azul
pcNewColor =(char *)malloc(strlen(pColor)) ;
if(NULL == pcNewColor)
{
Devolver NULL
}
strcpy(pcNewColor , pcColor );
Devuelve pcNewColor
}
Respuesta: El espacio de memoria solicitado es insuficiente y hay un ' \0 ' al final del string.
5. El siguiente programa espera generar str = hola mundo, indique el error:
char * GetStr(char *p)
{
p = " hola mundo
Devolver p;
}
void main()
{
char * str = NULL
if(NULL!= GetStr(str))
{
printf("\r\ n str = s ", str);
}
Return;
}
Respuesta: No se puede devolver una cadena, el Los parámetros se utilizan incorrectamente.