| | 1. Los árboles enhebrados consiguen algoritmos de recorrido iterativo sin necesidad de usar pilas |
| | Solo para el recorrido para el que ha sido enhebrado |
| | Una vez enhebrado cualquier recorrido puede hacerse iterativo sin pila |
| | Falso. Se debe utilizar una pila como estructura auxiliar o sino serán recursivos |
| | Ninguna de las anteriores |
| | No contesto... |
| |
| | 2. La implementación de un árbol binario mediante un vector: |
| | No se puede utilizar un vector |
| | Sólo es aconsejable si el árbol es balanceado |
| | Se puede utilizar el vector si queremos construir árboles enhebrados |
| | El árbol tiene que ser parcialmente ordenado para poder utilizar un vector |
| | No contesto... |
| |
| | 3. ¿Cómo debo recorrer un árbol de búsqueda binaria para obtener una secuencia ordenada de nodos? |
| | Inorden |
| | Preorden |
| | Postorden |
| | Por niveles |
| | No contesto... |
| |
| | 4. Las clases y funciones template permiten la parametrización de tipo. Al utilizarlas, el tipo genérico es reemplazado por el que se desea. El reemplazo lo hace: |
| | El compilador |
| | El enlazador (linker) |
| | Se produce cuando se ejecuta el programa (en tiempo de ejecución) |
| | Para las clases el compilador y para las funciones el enlazador |
| | No contesto... |
| |
| | 5. En C++ el constructor de copia (X(const X& x)) |
| | Permite el retorno de objectos por valor |
| | Necesita que la clase tenga al menos una función virtual para poder utilizarlo |
| | No es necesario si se sobrecarga el operador = (asignación) |
| | Ninguna de las anteriores |
| | No contesto... |
| |
| | 6. En un árbol de búsqueda binaria de n nodos: |
| | La eficiencia de búsqueda es tanto mayor cuanto más balanceado está el árbol |
| | En el peor de los casos la eficiencia de búsqueda es similar a la de una lista |
| | El hecho de que esté más o menos balanceado no influye en la eficiencia de búsqueda |
| | a) y b) |
| | No contesto... |
| |
| | 7. Dado el código, suponiendo que tiene todos los includes
class X
{
char *p_c;
public:
X (char *p)
{
p_c = new char[strlen(p)+1];
strcpy(p_c,p);
}
print()
{
printf("%p\n", p_c);// imprimir el puntero
};
X a("xxxx"); (1)
X b = a; (2)
a.print(); (3)
b.print(); (4)
|
| | En (3) y (4) se imprime el mismo valor |
| | En (3) y (4) se imprimen valores distintos |
| | Es un error de compilación porque en la clase X no está definido el operador = |
| | Es un error de compilación porque en la clase X no está definido el constructor de copia |
| | No contesto... |
| |
| | 8. Dado el siguiente prototipo de función:
int f(int w, const int& x, int& y, int *z);
la siguiente llamada:
f(m,n,o,p); suponiendo que compila correctamente |
| | Permite que las variables m y n puedan cambiar sus valores dentro de la función y que los cambios permanezcan después de la llamada |
| | Permite que las variables o y p puedan cambiar sus valores dentro de la función y que los cambios permanezcan después de la llamada |
| | Permite que las variables n y o puedan cambiar sus valores dentro de la función y que los cambios permanezcan después de la llamada |
| | Permite que las variables m y p puedan cambiar sus valores dentro de la función y que los cambios permanezcan después de la llamada |
| | No contesto... |
| |
| | 9. La diferencia entre una estructura y una clase es: |
| | La estructura permite tener solo datos públicos |
| | No hay diferencia |
| | Por defecto, los datos de una estructura son públicos mientras los datos de una clase por defecto son privados |
| | La estructura no puede tener datos protegidos |
| | No contesto... |
| |
| | 10. Dado el código:
int X=0;
int &Y=X; |
| | Y es un nombre alternativo para el objecto X |
| | La segunda línea da error de compilación |
| | Los objectos X e Y son independientes (al cambiar el valor de uno de estos el otro se conserva) |
| | Las referencias sólo se usan en la lista de parámetros de las funciones |
| | No contesto... |
| |
| | 11. Dado el código:
| int sz=10; |
(1) |
| class Table { |
(2) |
| }; |
(3) |
| Table* t1= new Table; |
(4) |
| Table* t2= new Table[sz]; |
(5) |
| delete t1; |
(6) |
| delete []t2; |
(7) |
|
| | La línea (7) da error de compilación pues los corchetes después del delete se necesitan sólo cuando se borra un vector |
| | La línea (6) da error de compilación, lo correcto es: delete []t1; |
| | Es correcto |
| | El programa da error de compilación porque la clase Table no contiene datos |
| | No contesto... |
| |
| | 12. Dado el programa:
class complex
{
float real;
float entera;
public:
complex(float a=0, float b=0): real(a), entera(b) {}
};
complex a(1,3.1);
complex b(2,2.1);
complex c=a+b;
|
| | Da error de compilación pues el operador + de datos de tipo complex no está sobrecargado |
| | Da error de compilación pues no existe el constructor por defecto para construir el objeto c |
| | El programa compila correctamente, al ejecutar utilizaría el operador + definido por defecto |
| | Da error de compilación pues se intenta asignar un valor a c antes de estar construido |
| | No contesto... |
| |
| | 13. Entre un constructor de copia y el operador de asignación de una clase: |
| | Una de las diferencias principales es que el constructor construye un nuevo objecto mientras el operador de asignación opera sobre un objeto ya existente |
| | No hay diferencia |
| | El constructor de copia existe por defecto mientras esto es falso para el operador de asignación |
| | El constructor de copia retorna el nuevo objeto mientras el operador de asignación no retorna nada |
| | No contesto... |
| |
| | 14. Escoger la frase correcta: |
| | El polimorfismo permite referirse a objetos de clases diferentes mediante el mismo elemento de programa y realizar la misma operación de diferentes formas, según sea el objeto que |
| | La herencia es una de las características principales de la programación orientada a objetos que permite definir jerarquías entre las clases y compartir heredando datos (variables |
| | La herencia se aplica entre objetos y no sobre clases |
| | a) y b) |
| | No contesto... |
| |
| | 15. En la clase vector de la STL: |
| | Las funciones push_back y push_front tienen la misma complejidad, en los dos casos se han de realocatar los elementos que existen ya en el vector |
| | Insertar n veces un 0 (es decir uno a uno) tiene la misma complejidad que insertar un vector de n elementos ceros usando como parámetro de la función insert un rango |
| | La función begin() retorna el valor del primer elemento del vector |
| | Ninguno de los anteriores |
| | No contesto... |
| |
| | 16. Dadas las definiciones:
class vector
{
public:
vector() { cout<<"v1 ";};
vector (int a) { cout<<"v2 ";};
};
class pila:public vector
{
public:
pila () { cout<<"p1 ";};
pila (int a) { cout<<"p2 ";};
};
y el programa principal:
void main (void)
{
pila a(3);
pila b[3];
}
Al ejecutar el programa obtendremos el mensaje:
|
| | p2 v2 p1 v1 p1 v1 p1 v1 |
| | v2 p2 v1 p1 |
| | v1 p2 v1 p1 v1 p1 v1 p1 |
| | No funcionaría porque no tenemos definido el operador [] para la clase pila |
| | No contesto... |
| |
| | 17. Si tenemos la clase ClasseTest y suponemos que esta codificada correctamente:
ClasseTest a,b;
donde:
class ClasseTest
{
...
public:
ClasseTest & operator= (const ClasseTest & In);
ClasseTest (const ClasseTest & In);
ClasseTest ();
ClasseTest& operator() (ClasseTest&);
...
};
y las siguientes líneas de código:
1) a=b;
2) ClasseTest c=b;
3) ClasseTest c(b);
4) c=a(b);
Cuál de las siguientes afirmaciones es cierta: |
| | En ninguna de las líneas se está llamando al constructor de copia |
| | Las líneas 2,3 y 4 están llamando al constructor de copia |
| | Sólo la línea 3 está llamando al constructor de copia |
| | Sólo la línea 2 y la 3 están llamando al constructor de copia |
| | No contesto... |
| |
| | 18. Dada la función:
int & funcion (int & e1, int & e2)
{
e1=e2-1;
if (e1>e2)
{
return e1;
}
else
{
return e2;
}
};
y el programa:
void main (void)
{
int a=1;
int b=4;
int c=0;
c=(funcion(a,b)=5);
cout << a << "," << b << "," << c << endl;
}
Suponiendo que compila y se ejecuta correctamente, la salida del programa serï |
| | 1,5,5 |
| | 3,5,5 |
| | 1,4,0 |
| | 0,5,5 |
| | No contesto... |
| |
| | 19. En la implementación de la práctica de la cola circular, ésta estará llena cuando: |
| | Top==(Contingut+Tamany) |
| | Inici==Top y (EmptyQueue o ColaVacia o CuaBuida)==0 |
| | Top-Inici==Tamany |
| | Ninguna de las anteriores |
| | No contesto... |
| |
| | 20. Dado el siguiente código, cuántas veces se llama al destructor de vector:
void main(void)
{
Vector< Vector < int> >Matriu a (6);
}
|
| | Ninguna porque no se hace ninguna llamada explícita a delete |
| | 6 veces |
| | 7 veces |
| | 36 veces |
| | No contesto... |
| |