Progra II

Con respecto a los registros tipo "Struct", señalar la opcion VERDADERA. Se trata de una estructura de datos heterogénea. En la definicion de un struct se pueden declarar campos que son también de tipo struct, estructuras anidadas del mismo tipo u otro diferente del que se está definiendo. El estándar fija estrictamente la colocación de los campos en una variable struct, siempre en posiciones consecutivas de memoria. No se puede dar valores iniciales a una variable de tipo struct en el momento de declaracion de dicha variable.

Sea la siguiente declaración: struct punto2D { _int x,y; }; Señale la opción VERDADERA: Esta definición crea un nuevo tipo de dato, pero no se produce reserva de memoria mientras que no se declare una variable de dicho tipo. Es una declaración de una variable de tipo struct. Para acceder al campo x de dicha variable punto2D se utilizará la expresión punto2D.x. La siguiente linea de código es incorrecta y produce un error de compilación: struct punto2D var = {5,16};. El identificador punto2D es el nuevo nombre del tipo de dato creado que se utilizará en la declaración de variables punto2D unaVariable;.

Sea la siguiente declaración: __struct usuario{ _____char nombre[50]; _____char apellidos[80]; _____int id; __}; ... y sea la siguiente línea de código de una función que recibe una variable de tipo struct por referencia: __void mostrarUsuario(struct usuario *u){ _____printf("Usuario: %s %s \t Id: %d\n", XXX,XXX,XXX); __} Seleccione la opción con las tres expresiones correctas a situar en los huecos dejados en el código: *(u).nombre, *(u).apellidos, *(u).id. (*u).nombre, (*u).apellidos, (*u).id. *(u)->nombre, *(u)->apellidos, *(u)->id. (*u)->nombre, (*u)->apellidos, (*u)->id.

Sean las siguientes declaraciones: __struct productos{ _____char categoria[50]; _____char producto[50]; _____int numReferencia; __}; __... __struct productos prod[10]; Cuál de las siguientes sentencias es INCORRECTA?. scanf("%d", &(prod[1].numReferencia));. scanf("%d", &(prod[1]->numReferencia));. scanf("%d", &((prod + 1)->numReferencia));. scanf("%d", &((*(prod + 1)).numReferencia));.

Sean las siguientes declaraciones: __struct alumno{ _____char nombre[20]; _____float notaMedia; __}; __struct clase{ _____struct alumno alumnos[25]; _____int aula; __}; __struct clase vectorClases[10]; Señale la sentencia INCORRECTA: printf("Nota Media: %f\n", vectorClases[1].alumnos[1].notaMedia);. printf("Nota Media: %f\n", (vectorClases + 1)->alumnos[1].notaMedia);. printf("Nota Media: %f\n", ((vectorClases + 1)->alumnos + 1)->notaMedia);. printf("Nota Media: %f\n", *((vectorClases + 1)->alumnos + 1).notaMedia);.

Sea el siguiente código: __enum Motor {gasolina=23, gasoil, hidrogeno=15, electrico=16, ninguno}; __enum Motor unCoche; __.... __for ( unCoche = gasolina; unCoche < ninguno; unCoche++) { _____printf("unCoche = %d\n",unCoche); __} Señalar cual de las siguientes afirmaciones es VERDADERA: El código es correcto, compila y el resultado de la ejecución será: unCoche = 23 unCoche = 24 unCoche = 15 unCoche = 16 unCoche = 17. El código es correcto y compila sin problemas, pero el bucle no itera ninguna vez. Dará un error de compilación ya que la declaracion del tipo enum Motor es errónea: los valores enteros no están ordenados ascendentemente. Dará un error de compilación ya que, la declaración del tipo enum Motor es correcta, pero la de la variable unCoche no, debido a que no se pueden declarar variables de tipo enum.

El tipo "union" consta de miembros. que comparten el mismo área de almacenamiento en memoria. para los que se debe especificar el tamaño en bits que ocuparán en memoria. que deben ser, a su vez, estructuras, en las que superponen sus miembros. que pueden ser de distintos tipos, siempre que esos tipos ocupen todos el mismo tamaño.

Sea el fichero de cabecera fichero.h con la siguiente definición de la variable varGlobal: __void function(void); __static int varGlobal; Sea el fichero de codigo fuente C, fichero.c: __#include <stdio.h> __#include "fichero.h" __void function(void){ _____varGlobal++; _____printf("varGlobal en funcion: %d\n",varGlobal); __} Y sea el fichero de codigo fuente C, principal.c: __#include <stdio.h> __#include "fichero.h" __int main(void){ _____int i; _____varGlobal = 100; _____function(); _____printf("varGlobal en main: %d\n",varGlobal); _____return 0; __} Señala la respuesta VERDADERA: Cuando se compilan y enlazan ambos ficheros se produce un error de enlazado del tipo "simbolo duplicado", indicando que al incluir el fichero "fichero.h" en ambos ficheros de codigo fuente, la variable varGlobal está definida dos veces. Cuando se compilan y enlazan ambos ficheros se produce un error de compilación indicando que no se pueden definir variables globales en un fichero de cabecera. Cuando se compilan y enlazan ambos ficheros no se produce ningun error, se crea un ejecutable y el resultado de su ejecución es: varGlobal en funcion: 1 varGlobal en main: 100. Cuando se compilan y enlazan ambos ficheros no se produce ningun error, se crea un ejecutable y el resultado de su ejecución es: varGlobal en funcion: 101 varGlobal en main: 101.

Sea la siguiente declaración: __#define SUMA(x,y) x+y Y sea la siguiente porción de código: __int main(void){ _____int a = 10, b= 20; _____... _____int x = SUMA(a,b)*2; _____printf("\El resultado almacenado en la variable x es %d\n", x); __} El resultado de la compilación y ejecucion de este codigo es: El código es correcto, compila y ejecuta correctamente y el resultado es 60. El código es correcto, compila y ejecuta correctamente y el resultado es 30. El código es correcto, compila y ejecuta correctamente y el resultado es 50. El código es incorrecto. Se produce un error de compilación porque el procesador no permite directivas con parámetros.

Sea la siguiente declaración: __struct ejemplo{ _____short int campo1:2; _____short int_______:0; _____short int campo2:3; };. El segundo campo, al no tener identificador, impilica bits de relleno entre los campos campo1 y campo2. La aplicación del operador sizeof sobre el tipo de dato struct ejemplo, sizeof(struct ejemplo), da como resultado 2 bytes. La aplicación del operador sizeof sobre el tipo de dato struct ejemplo, sizeof(struct ejemplo), da como resultado 4 bytes. Se produce un error de compilación al no haber proporcionado identificador como nombre del segundo campo.

Sean las siguientes declaraciones: struct treintaYDosBits{ unsigned bit0:1; unsigned bit1:1; unsigned bit2:1; unsigned bit3:1; unsigned bit4:1; unsigned bit5:1; unsigned bit6:1; unsigned bit7:1; unsigned bit8:1; unsigned bit9:1; unsigned bit10:1; unsigned bit11:1; unsigned bit12:1; unsigned bit13:1; unsigned bit14:1; unsigned bit15:1; unsigned bit16:1; unsigned bit17:1; unsigned bit18:1; unsigned bit19:1; unsigned bit20:1; unsigned bit21:1; unsigned bit22:1; unsigned bit23:1; unsigned bit24:1; unsigned bit25:1; unsigned bit26:1; unsigned bit27:1; unsigned bit28:1; unsigned bit29:1; unsigned bit30:1; unsigned bit31:1; }bits; Indique el código correcto para poder cargar un número real en la variable bits. bits = (struct treintaYDosBits)5.2;. float *pt; pt = (float*)&bits; *pt = 5.2;. *((struct treintaYDosBits *)&bits)= 5.2;. Todas las anteriores son incorrectas. En una variable de tipo struct no se puede cargar un valor real porque son de diferente tipo.

Sea la siguiente declaración al comienzo de un fichero de código fuente C, y fuera de toda función implementada en el mismo: extern int var; Señale cuál de las siguientes afirmaciones es VERDADERA: Define la variable var como una variable global de fichero, es decir, crea una variable global que sólo pueda ser accedida desde las funciones implementadas en el mismo fichero. Declara la variable var como una variable global de programa, es decir, se indica al compilador que la variable var está definida en otro fichero. Define la variable var como una variable global de programa, es decir, se indica al compilador que la variable var podrá ser declarada y utilizada por funciones implementadas en otro fichero. Se producirá un error de compilación: la palabra extern no puede ser utilizada en la declaracion de variables globales.

Con respecto a la orden make y los ficheros makefile, señale cuál de las siguientes afirmaciones es FALSA: Una regla de un fichero makefile define las dependencias entre un objetivo y un conjunto de ficheros, así como la línea de órdenes a ejecutar para producir el objetivo. La lista de dependencias de una regla indica la lista de ficheros cuyo atributo de fecha y hora de última modificación debe ser posterior al del objetivo para que se invoque la línea de órdenes para recuperar dicho objetivo. Un fichero makefile contiene un conjunto de reglas que especifican qué objetos se deben generar, incluyendo el objetivo principal, siendo el compilador el responsable de generar dichos objetos en el orden correcto para que se cumplan las dependencias especificadas en dichas reglas. La orden make utiliza las reglas contenidas en un fichero makefile junto con el atributo de fecha y hora de última modificación de los ficheros para establecer las tareas a realizar (compilación, enlazado, ...) y en qué orden, con el objetivo de minimizar el número de compilaciones.

Señala cuál de las siguientes afirmaciones es FALSA: Las funciones de reserva dinámica de memoria permiten reservar bloques de memoria cuyo tamaño sólo se conoce en tiempo de compilación. Las funciones de reserva dinámica de memoria permiten reservar bloques de memoria cuyo tamaño sólo se conoce en tiempo de ejecución. Las funciones malloc() y calloc() devuelven el valor NULL cuando no ha sido posible reservar el bloque solicitado en el del programa. Las funciones malloc() y calloc() reservan un bloque de memoria dinámicamente devuelven la dirección al primer byte de dicho bloque.

Sea el siguiente código: __int *vector; __... __vector = malloc(10*sizeof(int)); __ ... __free(vector); __for (i = 0; i< 10; i++) { _____printf("%d\n",vector[i]); __} Seleccione la opcion CORRECTA: El código es correcto, compila y se ejecuta siempre de forma correcta sin producir ningún error de ejecución, en ningún caso o situación. El código es incorrecto y se produce un error de compilación, ya que el valor devuelto por la función malloc() debe ser convertido, mediante un casting al mismo tipo de puntero vector. El código es incorrecto y se produce un error de compilación, ya que el compilador detecta que se va a realizar un acceso a una zona de memoria que ha sido previamente liberada. El código es correcto, compila y se ejecuta, generalmente sin problemas, mostrando el contenido del vector aunque estaría accediendo a una zona de memoria ilegalmente.

Se desea escribir una función que reserve, de forma adecuada, los bloques de memoria dinámica según la estrategia de la figura, donde cada registro tiene la siguiente estructura: __typedef struct empleados { _____char apellidos[30]; _____char nombre[15]; _____int matricula; __}tipoEmpleado; Señale la opción que presenta las declaraciones necesarias y el código correcto que realiza la reserva de los bloques de memoria dinámica de la figura: tipoEmpleado (*res)(numEmpleados); res = (tipoEmpleado*)malloc(sizeof(tipoEmpleado));. tipoEmpleado **res; int i; res = malloc(numEmpleados * sizeof(tipoEmpleado *)); for(i = 0; i < numEmpleados; i++) __res[i] = malloc(sizeof(tipoEmpleado));. tipoEmpleado *res; int i; res = malloc(numEmpleados * sizeof(tipoEmpleado *)); for(i = 0; i < numEmpleados; i++) __res[i] = malloc(sizeof(tipoEmpleado));. tipoEmpleado **res; res = malloc(numEmpleados * sizeof(tipoEmpleado));.

Se desea reservar memoria de forma dinámica para almacenar una matrix bidimensional de números reales utilizando: #define COLS 100 ... float (*mat)[COLS]; int numFil; ... numFil = 200; ... A continuación se presentan cuatro formas diferentes de invocar a la función de reserva de memoria dinámica, malloc(). Señalar la única que es INCORRECTA: mat = malloc(numFil * COLS * sizeof(float));. mat = malloc(numFil * COLS * sizeof(**mat));. mat = malloc(numFil * sizeof(float[COLS]));. mat = malloc(numFil * COLS * sizeof(mat[0]));.

int * SumarMatInt(int *matA, int *matB, int f, int c){ __int *matC, i, j; __if (matA != NULL && matB != NULL){ ____if (NULL != (matC = malloc(f*c*sizeof(int)))){ ______for (i=0; i < f; i++) ________for(j = 0; j < c; j++){ //línea 10 _________} ________return matC; _______} _________else __________return NULL; _____} _____else ______return NULL; __} Suma dos matrices bidimiensionales matA y matB, implementadas mediante una matriz unidimensional de enteros, devolviendo una matriz unidimensional, matC, que representa la matriz bidimensional resultado de la suma de las anteriores. Los parámetros f y c representan el número de filas y columnas de ambas matrices, respectivamente. En este código falta la línea número 10 por completar, que es la que realiza la suma de los valores individuales de las matrices operando, mediante recorrido por orden principal de filas. Esta fila es: *(matC[i*c]+j) = *(matA[i*c]+j) + *(matB[i*c]+j);. matC[i*f+j] = matA[i*f+j] + matB[i*f+j];. matC[i*c+j] = matA[i*c+j] + matB[i*c+j];. matC[i][j] = matA[i][j] + matB[i][j];.

Sea la siguiente declaración en C: typedef struct { __int **mat; __int nFil, nCol; }MatrizT; ... MatrizT *matriz1; ... Se supone que se han realizado, de forma correcta, todas las reservas de memoria necesarias para poder gestionar una matriz bidimensional de números enteros y de dimensiones adecuadas, utilizando la anterior declaración. De las siguientes expresiones en C, indicar cuál es la INCORRECTA si se desea acceder al elemento que está en la columa 4 de la fila 2. *((*(*matriz1).mat + 2)+4). *((*matriz1).mat[2]+4). *(matriz1->mat[2]+4). (*matriz1).mat[2][4].

typedef int tipoInfo; typedef struct tipoNodo{ __tipoInfo info; __struct tiponodo *sig; }tipoNodo; typedef tipoNodo * ListaEnlazada; int main(void){ ListaEnlazada lista, indice, nuevo; lista = NULL; for (int i=0;i<5;i++){ __nuevo = malloc(sizeof(tipoNodo)); __if(nuevo != NULL){ _____nuevo->info = i+1; _____nuevo->sig = lista; _____indice = lista; _____while(indice != NULL){ _______indice = indice->sig; _____} _____if(indice == NULL) _______lista = nuevo; _____else _______indice->sig = nuevo; __} }. El código es incorrecto y no compila. No se ha realizado el casting o coversión de tipo a tipoNodo * a la direcci´on de memoria devuelta por la función malloc (linea 4). El código es correcto, compila y se ejecuta sin dar ningún error de ejecución. Se crea una lista enlazada cuyos nodos tienen la siguiente secuencia de números enteros: 1,2,3,4,5. El código es correcto, compila y se ejecuta sin dar ningún error de ejecución. Se crea una lista enlazada cuyos nodos tienen la siguiente secuencia de números enteros: 5,4,3,2,1. El código es correcto, compila sin errores, pero se produce un error de ejecución debido a un acceso ilegal de memoria.(Segmentation fault: 11).

Sean las siguientes declaraciones: typedef struct tipoInfo{ __char nombre[25]; __int mat; }tipoInfo; typedef struct tipoNodo{ __tipoInfo info; __struct tipoNodo *sig; }tipoNodo; typedef tipoNodo *ListaEnlazada; Se pretende escribir una funcion que recorre una lista enlazada , muestra por pantalla el contenido del campo info y libera todos los nodos de dicha lista. Seleccionar entre las cuatro propuestas, la única INCORRECTA: void funcion(ListaEnlazada pt) { __tipoNodo *aBorrar; __for (aBorrar = pt; pt != NULL; aBorrar = pt) { _____printf("Nombre: %s %d\n",pt->info.nombre,pt->info.mat); _____aBorrar = pt; _____free(aBorrar); __} }. void funcion(ListaEnlazada pt) { __tipoNodo *aBorrar; __for (aBorrar = pt; pt != NULL; pt = pt->sig) { _____printf("Nombre: %s %d\n",pt->info.nombre,pt->info.mat); _____aBorrar = pt; _____free(aBorrar); __} }. void funcion(ListaEnlazada pt) { __tipoNodo *aBorrar; __for (aBorrar = pt; pt != NULL;) { _____printf("Nombre: %s %d\n",pt->info.nombre,pt->info.mat); _____pt = pt->sig; _____free(aBorrar); _____aBorrar = pt; __} }. void funcion(ListaEnlazada pt) { __tipoNodo *aBorrar = pt; __while (pt != NULL) { _____printf("Nombre: %s %d\n",pt->info.nombre,pt->info.mat); _____pt = pt->sig; _____free(aBorrar); _____aBorrar = pt; __} }.

En relación con las listas enlazadas, señalar la afirmación VERDADERA: La secuencia "lógica" de los nodos de una lista enlazada está determinada por la posición de dicho nodo en memoria. La secuencia "lógica" de los nodos de una lista enlazada está determinada por el valor almacenado en un campo de dichos nodos. Las listas enlazadas se crean en tiempo de compilación únicamente cuando se necesitan y se destruyen (liberan) cuando ya no son necesarias. La gestión de memoria dinámica de las listas enlazadas se considera un aspecto avanzado del compilador de C, ya que éste es el responsable de las reservas y liberaciones de memoria.

Con respecto al tratamiento de ficheros en C, selecciones la FALSA: Las funciones de bajo nivel no aportan ningún tipo de facilidad para la gestión de los datos a leer/escribir en el fichero, ni buffers intermedios ni ningún otro servicio como formato. En el sistema de ficheros ANSI de C el buffer asociado al stream únicamente se vuelca al dispositivo físico cuando se invoca a la función fclose(). Los ficheros binarios mantienen una correspondencia biunívoca entre la información en memoria principal y la información guardada en el fichero. Sea cual sea el dispositivo físico donde se vaya a escribir o leer, el sistema de ficheros ANSI lo transformo en un dispositivo lógico, denominado stream. El programador escribe en el stream y el sistema de E/S escribe en el fichero.

Dada la sentencia: fp = fopen("misdatos.txt","w+"); Indicar cuál de las siguientes afirmaciones es FALSA. Abre un fichero de texto en modo escritura/lectura. Si el fichero no existe lo crea. fp debe estar declarado como un puntero de tipo FILE. Si fp es distinto de NULL se podrá escribir una cadena de caracteres al comienzo del fichero de texto creado ejecutando: fprintf(fp,"Este es un archivo de prueba\n");. Si fp es distinto de NULL se podrá añadir una cadena de caracteres al final del fichero de texto abierto ejecutando: fprintf(fp,"Este es un archivo de prueba\n");.

typedef int tipoInfo; typedef struct tipoNodo{ __tipoInfo info; __struct tipoNodo *sig; }tipoNodo; typedef tipoNodo * ListaEnlazada; typedef ListaEnlazada * ListaEnlazadaRef; ListaEnlazada funcion (ListaEnlazadaRef raiz){ __tipoNodo * aux, *aux2, *aux3, *temp; __int x = 0; __aux2 = NULL; __temp = *raiz; __if (temp == NULL) return NULL; __while(temp != NULL){ _____if(x++%2){ _______if(aux2 == NULL) __________aux3 = aux2 = temp; _______else{ __________aux2->sig = temp; __________aux2 = aux2->sig; _______} _______if (temp == *raiz) __________aux = temp = *raiz = (*raiz)->sig; _______else { __________aux->sig = temp->sig; __________temp = aux->sig; _______} _______aux2->sig = NULL; _____} ______else { _______aux = temp; _______temp = temp->sig; _____} __} ___return aux3; } Todo este tocho es la definición de una lista enlazada. Ahora, suponiendo que se puede asociar un índice entero como posición a cada nodo, comenzando con la posición 0 en el nodo raíz, la posición 1 en el segundo nodo, etc, señalar la opción VERDADERA: La función recorre la lista referenciada por el parámetro raiz, extrayendo de la misma todos los nodos que ocupan posición par y finaliza devolviendo la lista resultante, es decir, la inicial pero sin los nodos extraídos, a través del puntero devuelto con el return. La función recorre la lista referenciada por el parámetro raiz, extrayendo de la misma todos los nodos que ocupan posición impar y finaliza devolviendo la lista resultante, es decir, la inicial pero sin los nodos extraídos, a través del puntero devuelto con el return. La función recorre la lista referenciada por el parámetro raiz, extrayendo de la misma todos los nodos que ocupan posición par y finaliza devolviendo dichos nodos extraídos en una lista enlazada a través del puntero devuelto con el return. La función recorre la lista referenciada por el parámetro raiz, extrayendo de la misma todos los nodos que ocupan posición impar y finaliza devolviendo dichos nodos extraídos en una lista enlazada a través del puntero devuelto con el return.

Con respecto a la orden make y los ficheros makefile, señale cuál de las siguientes afirmaciones es FALSA: Una regla de un fichero makefile define las dependencias entre un objetivo y un conjunto de ficheros, así como la línea de órdenes a ejecutar para producir el objetivo. La lista de dependencias de una regla indica la lista de ficheros cuyo atributo de fecha y hora de última modificación debe ser anterior al del objetivo para que se invoque la línea de órdenes para recuperar dicho objetivo. Un fichero makefile contiene un conjunto de reglas que especifican qué objetos se deben generar, incluyendo el objetivo principal. La orden make utiliza las reglas contenidas en un fichero makefile junto con el atributo de fecha y hora de última modificación de los ficheros para establecer las tareas a realizar (compilación, enlazado, ...) y en qué orden, con el objetivo de minimizar el número de compilaciones.

Son las siguientes expresiones totalmente equivalentes? #include <nombrearchivo.h> #include "nombrearchivo.h". Si, son totalmente equivalentes. No, la segunda es totalmente incorrecta. No, la primera es la directiva del preprocesador para incluir ficheros de cabecera localizados en los directorios de búsqueda por defecto del compilador , y la segunda es la misma directiva para incluir ficheros de cabeceros localizados en el directorio actual de trabajo, o en la ruta especificada en la propia directiva. No, la primera es la misma directiva para incluir ficheros de cabeceros localizados en el directorio actual de trabajo, o en la ruta especificada en la propia directiva, y la segunda es la directiva del preprocesador para incluir ficheros de cabecera localizados en los directorios de búsqueda por defecto del compilador.

Sobre la función de reserva dinámica de memoria: void *realloc(void *ptr, size_t size) donde ptr es el puntero a un bloque reservado previamente mediante malloc(), calloc() o realloc(), y size es el nuevo tamaño del bloque, señale cuál de las siguientes afirmaciones es FALSA. Si el argumento real para el parámetro size es 0 y ptr es no NULL, se comporta de forma igual que la función free(): libera el bloque referenciado por ptr y devuelve NULL o un puntero no nulo no utilizable. Si el argumento real para el parámetro ptr es NULL se comporta como la función malloc(), reservando un bloque de memoria de size bytes. Si la reserva de memoria del nuevo bloque falla, la función finaliza sin liberar el bloque de memoria apuntado por ptr, lo que implica que dicha dirección sigue siendo válida. Si la reserva de memoria del nuevo bloque falla, la función libera el bloque referenciado por ptr devolviendo NULL, de forma análoga a malloc() y calloc().

Sea la siguiente declaración de tipos y prototipo de función: typedef struct empleados { __char apellidos[30]; __char nombre[15]; __int matricula: }tipoEmpleado; typedef tipoEmpleado *tipoEmpleadoRef; tipoEmpleadoRef *crearRegistrosRef(itn numEmpleados, int *arrNum); int copiarRegistro(tipoEmpleadoRef destino, tipoEmpleadoRef origen); Y sea la siguiente declaración de variables: tipoEmpleadoRef *empleados, elEmpleado; tipoEmpleado unEmpleado = {"PEREZ PEREZ","PEDRO",1234}; ... empleados = crearRegistrosRef(20,&errNum); elEmpleado = empleados[12]; donde la función crearRegistrosRef() crea un vector de punteros a registro tipoEmpleado, y en cada celda de dicho vector almacena la dirección de memoria del primer byte de un bloque de memoria reservado dinámicamente de tamaño suficiente para almacenar un registro del tipo tipoEmpleado, y la función copiarRegistro() copia el contenido del registro referenciado por origen en el registro referenciado por destino devolviendo un valor entero indicando si ha tenido éxito o no. Indicar cuál de las siguientes NO es una invocaciñon correcta a esta última función. errNum = copiarRegistro(empleados[12],&unEmpleado);. errNum = copiarRegistro(&(*empleados[12]),&unEmpleado);. errNum = copiarRegistro(&empleados[12],&unEmpleado);. errNum = copiarRegistro(*(empleados + 12),&unEmpleado);.

Sea la siguiente función int procesarMatriz(int (*mat)[N], int filas, int columnas){ ... } donde mat representa una matriz bidimensional dinámica implementada mediante un vector de vectores de enteros. Si se desea obtener el tamaño físico de una fila, es decir, el número de bytes que ocupa una fila, la sentencia en C sería: tamFila = sizeof(mat[0]);. tamFila = sizeof(*(mat[0]));. tamFila = sizeof(mat);. Ninguna es correcta;.

Con respecto el uso de typedef, señalar cuál de las siguientes afirmaciones es VERDADERA: Permite al programador crear nuevos tipos de datos. Permite añadir nuevos nombres o alias para tipos de datos existentes. Permite crear constantes con nombres. Ninguna es correcta.

Sean las siguientes declaraciones: __struct nombre { _____char apellidos[80]; _____char nombre[30]; __}; __struct alumno { _____struct nombre nombreCompleto; _____int DNI [8]; __}; ¿Cuál de las siguientes expresiones permite acceder de forma correcta al carácter almacenado en la primera celda del vector nombre del quinto alumno del GrupoA?. (grupoA+4)->nombrecompleto.nombre[1];. *((*(grupoA + 4)).nombreCompleto.nombre);. *(grupoA + 4).nombreCompleto.nombre[0];. *(*(grupoA +4).nombreCompleto.nombre);.

Sean las siguientes declaraciones: #define MAXTEMPS 30 #define MAXPUNTOS 200 struct fecha{ __int dia, mes, anio; }; struct punto{ __char identificador[10]; __struct fecha enFecha; __int totalTemps; __double temps[MAXTEMPS]; }; struct punto *m[MAXPUNTOS]; ¿cuál de las siguientes expresiones permite acceder de forma correcta al carácter almacenado en la primera celda del vector nombre del quinto alumno del GrupoA?. (*m[5]).temps[2] = 48.5;. m[5] = malloc(sizeof(struct(punto)));. m[5]->enFecha.dia = 5;. *m[5]->enFecha.mes = 11;.

Sean las siguientes declaraciones de tipos: struct str1{ __int a; __char b[5]; }; struct str2{ __char b[5]; __int a; }; struct str3{ __int b; __char a[5]; }; En la función main() se realizan las siguientes declaraciones de variables: struct str unoStr = {23, "Hola"}, *pt; struct str2 dosStr; struct str3 tresStr; Y a continuación se encuentran las siguientes sentencias: pt = (struct str1 *)&dosStr; *pt = unoStr; pt = (struct str1 *)&tresStr; *pt = unoStr; printf("\n Primera struct (%d bytes): %2d %s\n",sizeof(unoStr),unoStr.a,unoStr.b); printf("\n Segunda struct (%d bytes): %2d %s\n",sizeof(dosStr),dosStr.a,dosStr.b); printf("\n Tercera struct (%d bytes): %2d %s\n",sizeof(tresStr),tresStr.b,tresStr.a); ¿Cuál será el resultado de la ejecución de estas sentencias? Señalar la única correcta. Primera struct (12 bytes): 23 ­ Hola Segunda struct (12 bytes): 23 ­ Hola Tercera struct (12 bytes): 23 ­ Hola. No se puede ejecutar porque se produce un error de compilación en las asignaciones del Tercera bloque de código dado que las estructuras que aparecen en dichas asignaciones son de distinto tipo. Primera struct (12 bytes): 23 ­ Hola Segunda struct (12 bytes): 0 – Tercera struct (12 bytes): 0 –. Primera struct (12 bytes): 23 ­ Hola Segunda struct (12 bytes): 0 – Tercera struct (12 bytes): 23 ­ Hola.

Sea la siguiente declaración; typedef struct { __int **mat; __int nFil, nCol; }MatrizT; ... MatrizT *matriz1; ... Se supone que se han realizado de forma correcta, todas las reservas de memoria necesarias para poder gestionar una matriz bidimensional de números enteros, y de dimensiones adecuadas, utilizando la anterior declaración. De las siguientes expresiones en C indicar cuál es la INCORRECTA si se desea acceder al elemento que está en la columna 3 de la fila 3: *(*((*matriz1).mat + 3)+3). *((*matriz1).mat[3]+3). *(*matriz1).mat[3]+3. (*matriz1).mat[3][3].

Sea la siguiente función: int ** crearMatInt (int f, int c) { __int **mat, i; __else ____return NULL; } que crea una matriz bidimensional, mat, implementada mediante un vector de punteros a entero, apuntando cada uno al primer byte de un bloque de memoria que representa una fila, y devuelve la dirección del primer byte al bloque que representa dicho vector de punteros. Los parámetros f y c representan el número de filas y columnas de la matriz a crear. En este código faltan las lineas de código de la 3 a la 14 y que realizan la reserva de memoria necesaria para la matriz. Estas líneas son: if(NULL != (mat = malloc(f*sizeof(int *)))){ ___for (i = 0; i < f; i++){ _____if(NULL == (mat[i] = malloc(c*sizeof(int)))){ ________for(i=0; i< f; i++) ___________free(mat[i]); ________free(mat); ________return NULL; _____} ____} ___}. if(NULL != (mat = malloc(f*sizeof(int *)))){ ___for (i = 0; i < f; i++){ _____if(NULL == (mat[i] = malloc(c*sizeof(int)))){ ________for(int j=0; j<= i; j++) ___________free(mat[j]); ________free(mat); ________return NULL; _____} ____} ___return mat; ___}. if(NULL != (mat = malloc(f*sizeof(int *)))){ ___for (i = 0; i < f; i++){ _____if(NULL == (mat[i] = malloc(c*sizeof(int)))){ ________for(i++; i>= 0; i--) ___________free(mat[i]); ________free(mat); ________return NULL; _____} ____} ___return mat; ___}. if(NULL != (mat = malloc(f*sizeof(int *)))){ ___for (i = 0; i < f; i++){ _____if(NULL == (mat[i] = malloc(c*sizeof(int)))){ ________for(int j = 0; j< i; j++) ___________free(mat[j]); ________free(mat); ________return NULL; _____} ____} ___return mat; ___}.

Sea el siguiente código fuente en C: int *a, *b, i; a=malloc(5*sizeof(int)); if(a != NULL){ __for(i = 0; i < 5; i++){ _____a[i] = 2 * i; __} //Código a completar por el estudiante. } El código a completar por el estudiante debe ser capaz de redimensionar el vector dinámico a, de manera que pase a ocupar 10 celdas, conservando los valores almacenados en el vector original en el código presentado y garantizando que, en caso de fallo en la reserva en dicho redimensionado, no se pierdan los datos originales. Señale, de las cuatro opciones, la única INCORRECTA: a = realloc(a, 10*sizeof(int)); for(a != NULL){ __for(i = 5; i < 10; i++){ _____a[i] = 2 * i; __} }. b = malloc(10*sizeof(int)); if(b != NULL){ __for(i = 0; i < 5; i++){ _____b[i] = a[i]; __} __for(i = 5; i < 10; i++){ _____b[i] = 2 * i; __} __free(a); __a=b; }. b = realloc(a, 10*sizeof(int)); if(b != NULL){ __for(i = 5; i < 10; i++){ _____b[i] = 2 * i; __} __a = b; }. b = malloc(10*sizeof(int)); if(b != NULL){ __for(i = 0; i < 5; i++){ _____b[i] = a[i]; _____b[i+1] = 2 * i; __} __free(a); __a = b; }.

¿Cuál de las siguientes funciones NO puede ser invocada desde otro fichero de implementación en C? Seleccione una: const void mifuncion(){ ... }. void mifuncion() { ... }. extern void mifuncion() { ... }. static void mifuncion() { ... }.

typedef int tipoInfo; typedef struct tipoNodo{ __tipoInfo info; __struct tipoNodo *sig; }tipoNodo; typedef tipoNodo * ListaEnlazada; int main(void) { __ListaEnlazada lista, indice, nuevo; __int i; __lista = NULL; __for(i=0; i < 5; i++) { ____nuevo = malloc(sizeof(tipoNodo)); ____if(nuevo != NULL){ ______nuevo->info = i+1; ______nuevo->sig = NULL; ____} ____indice = lista; ____while(indice->sig != NULL) { indice = indice->sig; ____} ____if(indice == NULL) ______lista = nuevo; ____else ______indice->sig = nuevo; __} __return 0; }. El código es correcto, compila y se ejecuta sin dar ningún error de ejecución. Se crea una lista enlazada cuyos nodos contienen la siguiente secuencia de números enteros: 1, 2, 3, 4, 5. El código es correcto desde un punto de vista sintáctico y compila sin errores, pero se produce un error de ejecución debido a un acceso ilegal de memoria (Segmentation fault: 11). El código es incorrecto y no compila. No se ha realizado el casting o conversión de tipo a tipoNodo * a la dirección de memoria devuelta por la función malloc(). El código es correcto, compila y se ejecuta sin dar ningún error de ejecución. Se crea una lista enlazada cuyos nodos contienen la siguiente secuencia de números enteros: 5, 4, 3, 2, 1.

La función free() recibe como único argumento un puntero a un bloque de memoria. Señale cuál de las siguientes afirmaciones es FALSA: Cuando el argumento recibido es una dirección de un bloque reservado con malloc(), calloc() opción realloc(), la invocación a free() libera el bloque de memoria referenciado. Cuando el argumento recibido es una dirección ya liberada con una invocación previa a free() el comportamiento está indefinido (depende de implementación). Cuando el argumento real es el puntero NULL se produce un error de ejecución (violación de segmento). Cuando el argumento recibido no es una dirección de un bloque reservado con malloc(), calloc() o realloc(), el comportamiento está indefinido (depende de implementación).

En la siguiente enumeracion ¿qué valores tienen? enum constantes { __constanteUno = 250, __constanteDos, __constanteTres = 10, __constanteCuatro, }. Error de compilación al no dar valores a constanteDos y constanteCuatro. Error de compilación al dar valores que no siguen un orden creciente a constanteUno y constanteTres. 250, 251, 10, 11. 250, 1, 10, 2.

A continuación, se presenta un listado de las operaciones que se puede realizar con variables de tipo struct como unidades. Indicar cuál de ellas es FALSA. Seleccione una: Obtención de la dirección de memoria de una variable de tipo struct. Comparar dos variables de tipo struct siempre que ambas variables sean del mismo tipo. Iniciar una variable de tipo struct con valores iniciales en la declaración. Asignación de dos variables del mismo tipo struct.

El tipo de dato que se debe utilizar en la declaración de un campo de bits de longitud 1 es: Int. Long. Unsigned char. Unsigned float.

Sea la siguiente declaración: struct estructura { __int a; __char b; __char c[90]; }; ... Y sea la siguiente porción del código en la función main(): int main(void) { __int iguales = 0; __struct estructura s1, s2 = {4, 'c', "ejemplo"}; __... __s1 = s2; __if (s1 == s2) iguales = 1; __... } Seleccione la opción CORRECTA. El código es correcto, la variable iguales toma el valor 1 al ejecutar las líneas mostradas. El código es incorrecto. No se puede asignar una variable de tipo struct a otra variable del mismo tipo. El código es incorrecto. No se pueden dar valores iniciales a una variable de tipo struct en su declaración. El código es incorrecto. No se pueden comparar dos variables de tipo struct aunque sean del mismo tipo.

Sean las siguientes declaraciones: struct fecha { __int dia, mes, anio; }; struct persona { __char nombre[20]; __char apellidos[50]; __struct fecha fNacimiento; }; ... struct persona vectorPersonas[10]; ¿Cuál de las siguientes sentencias es INCORRECTA?. scanf("%d",&(vectorPersonas[1].fNacimiento.dia));. scanf("%d",&((*(vectorPersonas + 1)).fNacimiento.dia));. scanf("%d",&((vectorPersonas +1)->fNacimiento.dia));. scanf("%d",&(*(vectorPersonas +1)->fNacimiento.dia));.

Sea la siguiente función: long long int funcion(void){ __static long long int res = 1; __static long long int a = 0; __static long long int b = 1; __res = b + a; __a = b; __b = res; __return res; } Que se invoca en el siguiente bucle: for (int i = 0; i < 6; i++) __printf("%lli\t",funcion()); La salida por pantalla resultante de la ejecución del bucle descrito es: 1 1 2 3 5 8. 1 2 3 5 8 13. 1 1 1 1 1 1. 0 1 1 2 3 5.

Suponiendo una lista enlazada que se defina como: typedef struct tipoNodo { __int info; __struct tipoNodo *sig; } tipoNodo; typedef tipoNodo *ListaEnlazada; ListaEnlazada funcion(ListaEnlazada *raiz, int x) { __tipoNodo *aux, *aux2, *aux3, *temp; __aux2 = NULL; __temp = *raiz; __aux = NULL; __if (temp == NULL) ____return NULL; __while (temp != NULL) { ____if (temp->info == x) { ______aux = temp; ______temp = temp->sig; ____} else { ______if (aux2 == NULL) { ________aux3 = aux2 = temp; ________temp = temp->sig; ______} else { ________aux2->sig = temp; ________aux2 = temp; ________temp = temp->sig; ______} ______if (aux == NULL) { ________*raiz = temp; ______} else { ________aux->sig = temp; ______} ______aux2->sig = NULL; ____} __} __return aux3; } Explícame qué hace esta función crack. La función recorre la lista referenciada por el parámetro raíz, extrayendo de la misma todos los nodos para los que el contenido del campo info es distinto al valor pasado a la función a través del parámetro formal x, y finaliza devolviendo dichos nodos extraídos en una lista enlazada a través del puntero devuelto con el return. La función recorre la lista referenciada por el parámetro raíz, extrayendo de la misma todos los nodos para los que el contenido del campo info es igual al valor pasado a través del parámetro formal x, y finaliza devolviendo dichos nodos extraídos en una lista enlazada a través del puntero devuelto con el return. La función recorre la lista referenciada por el parámetro raíz, extrayendo de la misma todos los nodos para los que el contenido del campo info es distinto al valor pasado a la función a través del parámetro formal x, y finaliza devolviendo la lista resultante, es decir, la inicial pero sin los nodos extraídos, a través del puntero devuelto con el return. La función recorre la lista referenciada por el parámetro raíz, extrayendo de la misma todos los nodos para los que el contenido del campo info es igual al valor pasado a la función a través del parámetro formal x, y finaliza devolviendo la lista resultante, es decir, la inicial pero sin los nodos extraídos, a través del puntero devuelto con el return.

Sea la siguiente función: long long int funcion(void){ __static long long int res = 1; __long long int a = 0; __long long int b = 1; __res = b + a; __a = b; __b = res; __return res; } Que se invoca en el siguiente bucle: for (int i = 0; i < 6; i++) __printf("%lli\t",funcion()); La salida por pantalla resultante de la ejecución del bucle descrito es: 1 1 2 3 5 8. 1 2 3 5 8 13. 1 1 1 1 1 1. 0 1 1 2 3 5.

Con respecto al tratamiento de ficheros en C, seleccione la opción VERDADERA: El lenguaje de programación C ofrece dos sistemas para procesar ficheros: uno de bajo nivel, que sólo sirve para procesar ficheros binarios, y otro de alto nivel que sólo sirve para procesar ficheros de texto. Los ficheros binarios mantienen una correspondencia biunívoca entre la información en memoria principal y la información guardada en el fichero. Pueden ser creados, visualizados y modificados con un editor de texto. En el sistema de ficheros ANSI de C el buffer asociado al stream únicamente se vuelca al dispositivo físico cuando se invoca la función fclose(). Sea cual sea el dispositivo físico donde se vaya a escribir o leer, el sistema de ficheros ANSI lo transforma en un dispositivo lógico, denominado stream. El programador escribe en el stream y el sistema de E/S escribe en el fichero.

Dada la sentencia: __fp = fopen("misdatos.txt","r"); Indicar cuál de las siguientes afirmaciones es FALSA: fp debe estar declarado como un puntero del tipo FILE. La manera correcta de cerrar el archivo, una vez utilizado, es: fclose(fp);. El puntero fp almacenará el valor NULL en el caso de que el archivo misdatos.txt no exista. Si fp es distinto de NULL se podrá escribir una cadena de caracteres en el archivo ejecutando: fprintf(fp, “Este es un archivo de prueba\n”);.

Se desea leer una línea de texto de un fichero encolumnado con la siguiente estructura. Suponiendo las siguientes declaraciones de variables: char nombre [45]; char provincia [15]; float talla; int edad; FILE *fp; Y suponiendo el fichero abierto correctamente y referenciado por el puntero fp, la línea de código sería: fscanf(fp, "%44[^\n]%14[^\n]%*c%4d%5f%*c", nombre, provincia, &edad, &talla);. fscanf(fp, “%44s%14s%4d%5f%*c”, nombre, provincia, &edad, &talla);. fscanf(fp, “%44[^ ]%14[^ ]%*c%4d%5f%*c”, nombre, provincia, &edad, &talla);. fscanf(fp, "%44s%14s%04d%5.2f", nombre, provincia, &edad, &talla);.

Se desea añadir una linea de texto en un fichero encolumnado siguiendo la siguiente estructura. Seleccione la respuesta correcta: FILE *fp = fopen("datos.txt", "a"); fprintf(escribe, "%44s%14s%04d%5.2f\n", "Juan Perez", "Madrid", 25, 1.80); fclose(fp);. FILE *fp = fopen("datos.txt", "w+"); fprintf(escribe, "%-44s%-14s%4d%5.2f\n", "Juan Perez", "Madrid", 25, 1.80); fclose(fp);. FILE *fp = fopen("datos.txt", "a"); fprintf(escribe, "%-44s%-14s%4d%5.2f\n", "Juan Perez", "Madrid", 25, 1.80); fclose(fp);. FILE *fp = fopen("datos.txt", "w+"); fprintf(escribe, "%44s%14s%04d%5.2f\n", "Juan Perez", "Madrid", 25, 1.80); fclose(fp);.

Se desea escribir una linea de texto en un fichero encolumnado siguiendo la siguiente estructura. Suponiendo el fichero abierto correctamente y referenciado por el puntero fp, la línea de código sería: fprintf(fp, "%44s%14s%04d%5.2f\n", "Juan Perez", "Madrid", 25, 1.80);. fprintf(fp, "%44s%14s%4d%5.2f\n", "Juan Perez", "Madrid", 25, 1.80);. fprintf(fp, "%44s%14s%04d%5.2f", "Juan Perez", "Madrid", 25, 1.80);. fprintf(fp, "%44s%14s%4d%5.2f", "Juan Perez", "Madrid", 25, 1.80);.