Aitor​ ​Sanmartin​ ​Ferreira

AEC1​ ​fundamentos​ ​de​ ​programación

Ejercicio​ ​1

1) Contesta a las siguientes cuestiones sobre expresiones

en​ ​C:

a. Indica las definiciones de variables erróneas y especifica dónde está el

error:
char​ ​a=72;
bien​ ​es​ ​correcto

float​ ​x=3,1e1.3;
Mal, el exponente debe ser un número entero, la coma en el 3,1 debe ser substituida por un punto para
que​ ​sea​ ​reconocido​ ​como​ ​un​ ​decimal​ ​por​ ​el​ ​compilador.
%HIQjW XIR IR GYIRXE UYI IP I\TSRIRXI HIFI WIV YR R•QIVS IRXIVS \! I ! \ ðò
Int​ ​z=2​ ​t=1;
Mal,​ ​falta​ ​una​ ​coma​ ​entre​ ​2​ ​y​ ​t.​ ​Para​ ​que​ ​esto​ ​funcionase​ ​tendría​ ​que​ ​ser​ ​“i​ nt​ ​z=2,t=1;​ ”.

int​ ​d=​ ​3.75;

Esto es erróneo ya que se está asignando un número ​double o ​floa​t, a un tipo de dato entero int​. Lo que
pasa aquí, es que el programa compilara y se ejecutará como si no pasara nada. Pero el valor de la
variable ​d​, no sería ​3.75 si no ​3​, se produciría un casting a un tipo de dato entero perdiéndose la parte
decimal.​ ​A​ ​menos​ ​que​ ​sea​ ​lo​ ​que​ ​se​ ​pretende​ ​esto​ ​no​ ​es​ ​correcto.

Int​ ​num​ ​==​ ​-2;

Mal, esto no compilara. Se esta usando el operador de igualdad, que comprueba que dos valores en una
expresión son iguales, para asignar un número a una variable. Lo correcto sería usar el operador de
asignación​ ​con​ ​un​ ​solo​ ​igual,​ ​“int​ ​num​ ​=​ ​-2​”.

unsigned​ ​dato​ ​=​ ​-3​ ​;

Esto es erróneo. El dato está declarado como un “unsigned”, por lo tanto no permite la representación de
números negativos. Para representar números negativos se usa el “twos complements”, reservando un
bit para el signo del número. Si es un unsigned el patrón de unos y ceros que representa el número ​-3​,
corresponde​ ​a​ ​un​ ​número​ ​muy​ ​grande​ ​en​ ​un​ ​tipo​ ​unsigned.

double​ ​z=​ ​0.67E-2;

Esto​ ​es​ ​válido.

b. Teniendo en cuenta la definición de variables int a=1, b=15 ; halla los

valores que sucesivamente va tomando la variable ​a ​en las siguientes
expresiones:

a+=2;​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​//En​ ​esta​ ​línea​ ​el​ ​valor​ ​de​ ​ ​ ​a​ ​=​ ​3

b++;​ ​ ​a=b+1;​​ ​ ​ ​ ​//En​ ​esta​ ​línea​ ​el​ ​valor​ ​de​ ​ ​a=17
a=(float)b/3;​​ ​ ​ ​ ​//En​ ​esta​ ​línea​ ​el​ ​valor​ ​de​ ​ ​a=5
a=b%2–1;​​ ​ ​ ​ ​ ​ ​ ​ ​//​ ​En​ ​esta​ ​línea​ ​el​ ​valor​ ​de​ ​ ​a=-1
%UYu IP STIVEHSV XMIRI TVMSVMHEH WSFVI EWu UYI WIVj E! ! !
 c. Escribe el resultado de las siguientes expresiones aritméticas:

15*2–13%3​​ ​=​ ​29

​ ​2e5/3+2e3​​ ​=​ ​68666.7
​ (​ int)​ ​200​ ​/​ ​3​ ​= 66
​ (​ (7–5)*11​ ​)/​ ​(2*(1-2))​​ ​=​ ​-11

d. Escribe el resultado de las siguientes expresiones lógicas:

)R IWXI GEWS IP VIWYPXEHS IW XVYI TSVUYI XIRIQSW
​ ​9/3==3​ ​&&​ ​8>5​ ​||​ ​2>4:​ ​false !! IW XVYI " XEQFMqR ] " IW JEPWI TSV PS UYI UYIHE
XVYI XVYI `` JEPWI " XVYI `` JEPWI " XVYI
(8​ ​<5*2​ ​||2>9)&&5!=2*3:​ ​true

6&4:
Dado que el número es pequeño nos dará de sobra, usar 1 byte para representar los
números:
​ ​ ​ ​ ​ ​ ​ ​ ​0000​ ​0110​ ​=​ ​6
​ ​ ​ ​ ​ ​&​ ​0000​ ​0100​ ​=​ ​4
​ ​ ​ ​ ​ ​ ​ ​-------------------
​ ​ ​ ​ ​ ​ ​ ​ ​ ​0000​ ​0100​ ​=​ ​4
​ ​3|5:
​ ​Usamos​ ​1​ ​byte​ ​para​ ​representar​ ​los​ ​números:

​ ​ ​ ​ ​ ​ ​ ​ ​ ​0000​ ​0011​ ​=​ ​3

)P STIVEHSV ​ ​ ​ ​ ​ ​&​ ​ ​0000​ ​0101​ ​=​ ​5
IW YR SV ` ​ ​ ​ ​ ​ ​ ​ ​-------------------
​ ​ ​ ​ ​ ​ ​ ​ ​ ​ ​0000​ ​0001​ ​=​ ​1
! ]E UYI ` ! ` ! ] ` !
Archivo: /home/javier.llorente.a/Escri…/codigoFuente/ejercicioDos.cpp Página 1 de 2

/
**********************************************************************************************************
* Ejercicio )\GIPIRXI XVEFENS ETPMGERHS ]E PEW JYRGMSRIW ] EHIQjW HERHS STGMSRIW EPXIVREXMZEW
1 E JYRGMSRIW GSQS XS[TTIV *
* Autor: Aitor Sanmartin
Ferreira *
* Asignatura: Fundamentos de programación , Grado Ingieneria informática,
Udima *
* Profesor: Javier LLorente
Ayuso *
* Actividad: Actividad de Evaluación continua AEC1, Ejercicios prácticos de Programación C+
+ *
*
*
* Programa: Contador
Vocales *
* Cuenta las vocales introducidas por el usuario en un bucle con 10 repeticiones, en
caso *
* de poner una vocal y sus correspondientes mayúsculas se aumenta numVocales. Al final el
programa *
* muestra el número de vocales
introducidas. *
*
*
*
Entorno:
*
*
MACROS: *
* NUM_CHARS_IGNORED , representa el número de caracteres a limpiar de la entrada
estandar *
* MAX_ITERACIONES, representa el número total de iteraciones del
bucle *
*
VARIABLES: *
* char: cracter, caracter introducido por el
usuario *
* int: numVocales, número total de vocales
introducida *
* CLASES Y
OBJETOS: *
* std::cout, std:cin , estandar output y standar
input *
*
FUNCIONES: *
* toupper: convierte minusculas en
mayusculas *
* contarVocal: devuelve 1 si el caracter es una vocal, si no devuelve 0, coge un char como
argumento *
*
INCLUDES:
*
* iostream y
cctype *
* Entrada: caracter o
letra *
* Salida: Numero de vocales
introducidas *
***********************************************************************************************************
#include <iostream>
#include <cctype>
/******************************************************************************
* MACROS: NO magic numbers *
*******************************************************************************/
#define NUM_CHARS_IGNORED 200
#define MAX_ITERACIONES 10
/*********************************************
* Declaracion de la funcion contarVocal *
**********************************************/
int contarVocal(char);
//Inicio programa
int main(int argc, const char * argv[]) {
Archivo: /home/javier.llorente.a/Escri…/codigoFuente/ejercicioDos.cpp Página 2 de 2

int numVocales(0);//número total de vocales introducidas

char caracter('\0');//caracteres que introduce el usuario

for ( int contador = 0; contador < MAX_ITERACIONES; ++contador){//mientras contador sea menor que
10
std::cout << "¿Introduce un caracter?:";
std::cin.get(caracter); //recogemos un caracter de la entrada y rechazamos el resto
std::cin.ignore(NUM_CHARS_IGNORED,'\n');// limpiamos los restos que puedan quedar en el buffer
numVocales += contarVocal(caracter);//llamamos a la funcion, si hay una vocal devuelve 1 y lo
suma a numVocales si no devuelve 0
}
//Imprimimos en pantalla el número de vocales introducidas
std::cout << "\nNúmero de vocales introducidas = " << numVocales << std::endl;

return 0;
//Fin programa
}
/**********************************************
* Implementación de la funcion contarVocal *
***********************************************/
int contarVocal(char caracter){
// si es mayuscula lo transformamos en minuscula
// si es minusucla nos aseguramos que es minuscula
switch(tolower(caracter)){
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
return 1;
}
return 0;

/*

Podriamos proporcionar nuestra propia funcion para convertir mayusculas en minusculas

pero la libreria estandar ya nos ofrece una, no reinventamos la rueda

char tolower( char dato){

if(dato >= 65 && dato <= 90) {

return dato + 32; 0E JYRGMzR UYI EUYu TVSTSRIW GSR PE XVEWPEGMzR HI
}else if(dato >= 97 && dato <=122){ GEVEGXIV IR PE XEFPE %7'-- IW TIVJIGXE
return dato;
}else {
return -1;
}

}*/
Archivo: /home/javier.llorente.a/Escri…codigoFuente/ejercicioTres.cpp Página 1 de 2

/****************************************************************************************************
* Ejercicio 2 )NIVGMGMS TIVJIGXS *
* Autor: Aitor Sanmartin Ferreira *
* Asignatura: Fundamentos de programación , Grado Ingieneria informática, Udima *
* Profesor: Javier LLorente Ayuso *
* Actividad: Actividad de Evaluación continua AEC1, Ejercicios prácticos de Programación C++ *
* *
* Programa: Números Romanos *
* El programa dado un número romano , nos indica su correspondiente valor en decimal *
* *
* Entorno: *
* MACROS: *
* I,V,X,L,C,D,M representan los números romanos y sus valores. *
* NUM_CHARS_IGNORED , representa el número de caracteres a limpiar de la entrada estandar *
* VARIABLES: *
* char: inRomano, número romano introducido por el usuario *
* int: nDecimal, número romano traducido a decimal *
* CLASES Y OBJETOS: *
std::cout, std:cin , estandar output y standar input *
* FUNCIONES: *
* toupper: convierte minusculas en mayusculas *
* convertirAdecimal: acepta un char como argumento, y transforma un número romano en decimal *
* INCLUDES: *
* iostream y cctype *
* Entrada: Numero romano *
* Salida: Numero decimal *
*****************************************************************************************************/
#include <iostream>
#include <cctype>
/******************************************************************************
* MACROS: números romanos y sus correspondientes en decimal. NO magic numbers *
*******************************************************************************/
#define I 1
#define V 5
#define X 10 )P YWS HI IWXEW GSRWXERXIW S RSQFVIW WMQFzPMGSW RS IW RIGIWEVMS EYRUYI WYTSRKS UYI XI
#define L 50 TYIHIR WIVZMV TEVE SXVSW TVSKVEQEW GSQS TSV IN XVEHYGMV YR R•QIVS GSQTPIXS IR VSQERSW
#define C 100 E HIGMQEP YWERHS YR EPKSVMXQS ZSVE^ TSV INIQTPS
#define D 500
#define M 1000
// número de datos a descartar del buffer, en caso de haber introducido mas de uno
#define NUM_CHARS_IGNORED 200
/*********************************************
* Declaracion de la funcion convertirAdecimal*
**********************************************/
int convertirAdecimal(char);

//Inicio del programa

int main(){

char inRomano;// input numero Romano

std::cout << "Introduce uno de los siguientes números (I, V, X, L, C, D, M):";

// extraemos del buffer un caracter y solo uno
std::cin.get(inRomano);
// limpiamos cualquier dato extra que haya podido quedar en el stream, o buffer de entrada
std::cin.ignore(NUM_CHARS_IGNORED,'\n');
/* convertimos el numero romano en decimal.
si el nDecimal se corresponde con algun número de nuestra tabla
entonces mostramos su valor en decimal */
if(int nDecimal = convertirAdecimal(inRomano)) {
std::cout << "El valor de "<< inRomano << " es " << nDecimal << ".\n";
}
else {
/* si es 0 no existe en nuestra tabla de números romanos por lo tanto no es valido,
mostramos el mensaje de que no es válido */
std::cout << "El número introducido no es válido\n";
}

return 0; //Fin del programa

}
/*************************************************
* Implementación de la funcion convertirAdecimal *
Archivo: /home/javier.llorente.a/Escri…codigoFuente/ejercicioTres.cpp Página 2 de 2

**************************************************/
int convertirAdecimal(char dato){

// si dato coincide con algun simbolo de los números romanos

// devolvera su valor en decimal si no devuelve 0
switch(dato){
case 'I': return I;
case 'V': return V;
case 'X': return X;
case 'L': return L;
case 'C': return C;
case 'D': return D;
case 'M': return M;
}
return 0;
}
Archivo: /home/javier.llorente.a/Escri…digoFuente/ejercicioCuatro.cpp Página 1 de 2

/****************************************************************************************************
* Ejercicio 4 *
* Autor: Aitor Sanmartin Ferreira *
* Asignatura: Fundamentos de programación , Grado Ingieneria informática, Udima *
* Profesor: Javier LLorente Ayuso *
* Actividad: Actividad de Evaluación continua AEC1, Ejercicios prácticos de Programación C++ *
* *
* Programa: numero de Cifras de un numero entero *
* Imprime en pantalla si el numero introucido tiene una,dos,tres o mas cifras *
* *
* Entorno: *
* MACROS: *
* NUM_CHARS_IGNORED , representa el número de caracteres a limpiar de la entrada estandar *
* VARIABLES: *
* int: numero,representa el numero introducido por el usuario *
* std::cout, std:cin: estandar output y standar input. *
* FUNCIONES: *
* contarCifras: cuenta el numero de cifras que hay y lo imprime en pantalla *
* INCLUDES: *
* iostream *
* Entrada: numero *
* Salida: cantidad de cifras que contiene el número *
*****************************************************************************************************/
#include <iostream> )NIVGMGMS TIVJIGXS WzPS YRE TVSTYIWXE HI QINSVE IR PE JYRGMzR
/********************************************
* MACROS: NO magic numbers *
TSHVuEW LEGIV UYI HIZYIPZE IP VIWYPXEHS HIP GSRXIS HI GMJVEW GSQS
*********************************************/IRXIVS WMIRHS MRX GSRXEV'MJVEW MRX RYQIVS
#define NUM_CHARS_IGNORED 1000
/********************************************
* Declaracion de la funcion contarCifras *
********************************************/
void contarCifras(int);

//Inicio programa
int main() {

int numero(0);
//mientras sea verdadero ejecutaremos el programa
while(true) {

std::cout << "Introduce un número:";

if(!(std::cin >> numero)) { // si la recogida de datos falla devuelve 1
std::cin.clear();//restauramos la entrada
std::cin.ignore(NUM_CHARS_IGNORED,'\n');// ignoramos todo lo que haya
std::cerr << "Error!!:entrada no válida" << std::endl; //avisamos de que ocurrio un error
continue;
}
/* Si no falla la entrada e introducimos algo como: 34asdf, esos
caracteres quedaran en la entrada. Por lo tanto, seria recomendable
limpiar el buffer de entrada.
Podemos comprobar que es cierto con el metodo std::cin.gcount() que devuelve
el numero de caracteres ignorados. si introducimos 34r dira que ha
eliminado dos caracteres la 'r' y el salto de linea '\n':

std::cout << std::cin.gcount() << std::endl;

*/
std::cin.ignore(NUM_CHARS_IGNORED,'\n');
//comprobamos que no sea negativo, si es asi, salimos del loop y acabamos el programa
if(numero < 0){
break;
}
// contamos y decimos cuantas cifras tiene el numero
contarCifras(numero);
}
return 0;//fin programa
}

/*********************************************
* Implementacion funcion contarCifras *
*********************************************/
void contarCifras( int numero ) {
Archivo: /home/javier.llorente.a/Escri…digoFuente/ejercicioCuatro.cpp Página 2 de 2

if(numero < 10) {

std::cout << "El " << numero << " tiene una cifra"<< std::endl;
}
else if( numero < 100) {
std::cout << "El " << numero << " tiene dos cifras"<< std::endl;
}
else if (numero < 1000){
std::cout << "El " << numero << " tiene tres cifras"<< std::endl;
}else{
std::cout << "El " << numero << " tiene más de tres cifras"<< std::endl;
}