Iniciando en C++: GameStats – Parte 2

Continuemos con la segunda parte de nuestro ejercicio de GameStats. Antes de comenzar veamos como ha quedado nuestro código luego de la primera parte:

#include <iostream>

void mostrarAtributosArma()
{
std::cout << "================== ATRIBUTOS DEL ARMA ==================" << std::endl;
std::cout << "Nombre: RW1" << std::endl;
std::cout << "Variante : Guardian" << std::endl;
std::cout << "Clase : Profesional" << std::endl;
std::cout << "Descripción : Arma de riel de mano, capaz de detener el combate.La mejor en su clase para causar daño" << std::endl;
std::cout << "Daño : " << 16 << std::endl;
std::cout << "Precisión : " << 7 + 1 << std::endl;
std::cout << "Cadencia de Fuego : " << 2 << std::endl;
std::cout << "Rango : " << 6 << std::endl;
std::cout << "Manejo : " << 7 - 1 << std::endl;
std::cout << "Movilidad : " << 12 << std::endl;
std::cout << "--------------------------------------------------------" << std::endl;
}

int main()
{
mostrarAtributosArma();
return 0;
}

Listo? Continuemos entonces.


En esta parte del ejercicio evaluaremos como mostrar los datos de un clan multijugador de Call Of Duty: Advanced Warfare, así que lo primero que deberíamos hacer es analizar los datos que vamos a presentar.

Perfil de Clan

Perfil del Clan

Perfil del Clan

  • Nombre: ATLAS
  • Diminutivo (tag): ATL
  • Lema: El poder lo cambia todo
  • Estadísticas del clan:
    • Nivel: 11
    • Experiencia Acumulada: 90000
    • Experiencia para Siguiente Nivel: 20000
    • Miembros: 13
    • Relación Muertes/Muertos: 0.91
    • Relación Victorias/Derrotas: 0.37

Si bien no son todos los datos que aparecen en pantalla, creo que son suficientes para ilustrar la idea que vamos a plantear con la función mostrarFichaClan().

Función mostrarFichaClan()

En esta función mostraremos los datos del clan que ya hemos definido anteriormente. NOTA: Para no tener que hacer una impresión completa del código cada vez que modifiquemos la estructura del mismo, me limitare a mostrar los cambios según las funciones que queramos modificar. Primero que nada procedamos a modificar la función main() de la siguiente manera:

int main()
{
mostrarAtributosArma();
mostrarFichaClan();
return 0;
}

Luego, procedamos a definir la función propiamente dicha, recuerda que esta definicion debe colocarse antes que la de la función main(); veamos el código:

void mostrarFichaClan()
{
char* nombre = "ATLAS";
char* tag = "ATL";
char* lema = "El poder lo cambia todo";
int experienciaAcumulada = 90000;
int experienciaSiguienteNivel = 20000;
short int nivel = 11;
unsigned short int miembros = 13;
float relacionMuertesMuertos = 0.91f;
float relacionVictoriasDerrotas = 0.37f;

std::cout << "================== PERFIL DEL CLAN =====================" << std::endl;
std::cout << "Nombre : " << nombre << std::endl;
std::cout << "Tag : [" << tag << "]" << std::endl;
std::cout << "Lema : " << lema;
std::cout << "Estadísticas : " << std::endl;
std::cout << " - Nivel : " << nivel << std::endl;
std::cout << " - Experiencia Acumulada : " << experienciaAcumulada << std::endl;
std::cout << " - Experiencia para Siguiente Nivel : " << experienciaSiguienteNivel << std::endl;
std::cout << " - Miembros : " << miembros << std::endl;
std::cout << " - Relacion Muertes/Muertos : " << relacionMuertesMuertos << std::endl;
std::cout << " - Relacion Victorias/Derrotas : " << relacionVictoriasDerrotas << std::endl;
std::cout << "--------------------------------------------------------" << std::endl;
}

Intimidante, no es así? Veamos el programa en ejecución y confirmemos su funcionamiento

mostrarPerfilClan()

mostrarPerfilClan()

El shock en el código viene de que hemos decidido implementar variables para manejar los valores que se mostraran en los diferentes cout que utilizamos, esto ha sido un cambio radical en el modo en el que venimos desarrollando nuestros programas. Estudiemos un poco como funcionan las variables en C++ para luego apreciar que hemos hecho en esta función.

Variables en C++

Entendamos que una variable no es mas que la representación de un valor a través de un nombre; dicho esto entendamos que en los lenguajes de programación tipificados (es decir que manejan tipos) comúnmente una variable consta de tres partes

  1. Tipo de dato
  2. Etiqueta o nombre
  3. Valor de la variable.

De esta manera cuando en C++ declaramos una variable como: int X = 0; El tipo seria int, el nombre es X y su valor es 0. Es muy importante que entendamos los tipos que estamos utilizando en nuestro programa, por lo que vamos a ver los diferentes tipos de datos que podemos usar de forma nativa en C++.

Tipos Fundamentales en C++

Al mínimo de los niveles, todas las variables que definimos en C++ son valores numéricos; conforme vamos A nivel básico podemos decir que C++ maneja dos tipos de datos fundamentales:

  • Caracteres Alfanuméricos y Especiales .
  • Escalares o Numéricos.

El resto de los tipos son derivados  de estos dos valores. NOTA: Existe una tercera categoría de punteros y referencias a memoria, pero estos los estudiaremos a nivel mas avanzado.

Tipos Caracter

Los valores de tipo caracter se definen con la palabra clave char; y si comprendemos su propósito, son muy sencillos de entender:

  • Un caracter es cualquier valor que no se puede utilizar en una operación aritmética.

De esta manera si te digo que la letra ‘a’ es un caracter, pero también el numero ‘1’ lo es, una coma, un espacio en blanco, el signo de ‘+’, todos estos son caracteres. Simplemente son cualquier símbolo cuyo propósito no sea una operación matemática.

Estoy seguro que esta no es la definición que normalmente vemos en un libro, pero a nivel practico es la manera mas clara en la que podemos verlo.

Permiteme ilustrarte esta idea con un sencillo ejemplo, escribe rápidamente un programa en el que hagas solo la siguiente operación en el main():

char a = '1'; std::cout << a + 1;

El valor que obtendrás por pantalla no es 2, de hecho en mi sistema me muestra 50 (si manejamos el mismo sistema operativo y codificación de sistema deberíamos obtener el mismo valor). Te preguntaras que es lo que ocurre? pues que sencillamente el caracter ‘1’ es un valor de muestra, que en el trasfondo tiene un valor numérico que le permite a C++ trabajar con él. El ‘1’ que manejamos en el valor no es un valor numérico según lo entiende el lenguaje, es un caracter numérico.

NOTA: Existen funciones especiales que permiten realizar conversiones de caracteres numéricos en valores numéricos. No estoy seguro si las estudiaremos pero te garantizo que están disponibles en el estándar C++.

Hay dos maneras de declarar variables de caracteres:

char a = 'b';

char* cadena = 'una cadena de caracteres';

A nivel practico, vemos que char a nos permite almacenar solo un caracter en su variable, mientras que char* cadena nos permite almacenar tantos caracteres como el compilador y la memoria permitan (comúnmente se habla de 256 caracteres).

A nivel programático, podemos decir que char a es una variable simple, mientras que char* cadena es un arreglo de valores; esta diferencia es considerable cuando estudiemos distribución de memoria mas adelante.

Tipos Escalares

Los valores numéricos son un poco mas complejos pero tampoco son nada del otro mundo. Hay dos clasificaciones claras en los valores que se manejan:

  • Valores enteros, es decir que no manejan decimales
    • int, bool
  • Valores de punto flotante, es decir que manejan decimales
    • float, double
Booleanos

Primero que nada tengo que aclarar algo, si bien bool es la palabra clave para determinar valores booleanos (es decir valores que definen VERDADERO o FALSO), su verdadero valor es un entero. De esta forma podemos decir que el valor true es igual a 1 y false es igual a 0; bool variable = 1; bool otravariable = true; Ambos casos son validos y ambas variables tienen el mismo valor.

Integers

Las variables int nos permiten trabajar los valores numéricos simples, es decir sin valores decimales. Estas variable son capaces de almacenar 4,294,967,296 valores. Existen también dos formas en las que podemos aplicar a los valores enteros, los mismos son:

  • short, delimita el rango de valores a 65,536 valores
  • long, que por defecto mantiene los 4,294,967,296 valores aunque teóricamente puede reservarse mas espacio para sus valores.

Es posible omitir la palabra int al declarar las variables si usamos los modificadores de tamaño; de esta manera podemos decir que: short int variableCorta; long int variableLarga; Es lo mismo que short variableCorta; long variableLarga; Igualmente hay dos modificadores adicionales

  • signed, la variable manejara valores positivos y negativos, esta es la forma por defecto en la que funciona int.
  • unsigned, para manejar valores sin signo de menos, esto le permite al compilador obviar los valores negativos e incrementar el valor de positivos en rango.
Float y Double

Estos son los tipos de variables que manejan decimales, la diferencia primordial que existe entre ellos es la cantidad de decimales que son capaces de manejar.

  • float maneja 3.4E +- 38 (es decir 7 dígitos significativos en el punto decimal)
  • double maneja 1.7E +- 308 (es decir 15 dígitos)

Un punto importante a tomar en consideración es que para C++; todas las expresiones que involucren un entero, se resuelven en forma de enteros, es decir si declaramos la siguiente variable:

float a = 1/2;

El valor de a sera 0, ya que C++ desechara el valor decimal que corresponde a esa operación (esto es valido para todas las operaciones aritméticas). Este inconveniente lo resolvemos facilmente si implementamos los valores escalares con numéros decimales

float a = 1.0/2.0;

Aunque de esta manera el compilador entiende que 1.0 y 2.0 son valores de tipo double, por lo que asigna mas recursos de memoria que los quizás sean necesarios.

Es por esto que en mi opinión personal es mejor especificar estos valores directamente como float utilizando una “f” luego del valor como vemos en el siguiente ejemplo:

float a = 1.0f/2.0f;

Valores Fundamentales

Me gustaría dejarte esta tabla de valores para los tipos fundamentales como referencia futura.

Tabla de Valores de Tipos Fundamentales

Tabla de Valores de Tipos Fundamentales

Función mostrarFichaClan() – Parte 2

Ya que hemos aprendido los diferentes tipos de variables y la forma en la que las mismas se declara, volvamos a ver el código de mostrarFichaClan()

void mostrarFichaClan()
{
char* nombre = "ATLAS";
char* tag = "ATL";
char* lema = "El poder lo cambia todo";
int experienciaAcumulada = 90000;
int experienciaSiguienteNivel = 20000;
short int nivel = 11;
unsigned short int miembros = 13;
float relacionMuertesMuertos = 0.91f;
float relacionVictoriasDerrotas = 0.37f;

std::cout << "================== PERFIL DEL CLAN =====================" << std::endl;
std::cout << "Nombre : " << nombre << std::endl;
std::cout << "Tag : [" << tag << "]" << std::endl;
std::cout << "Lema : " << lema;
std::cout << "Estadísticas : " << std::endl;
std::cout << " - Nivel : " << nivel << std::endl;
std::cout << " - Experiencia Acumulada : " << experienciaAcumulada << std::endl;
std::cout << " - Experiencia para Siguiente Nivel : " << experienciaSiguienteNivel << std::endl;
std::cout << " - Miembros : " << miembros << std::endl;
std::cout << " - Relacion Muertes/Muertos : " << relacionMuertesMuertos << std::endl;
std::cout << " - Relacion Victorias/Derrotas : " << relacionVictoriasDerrotas << std::endl;
std::cout << "--------------------------------------------------------" << std::endl;
}

Vemos entonces como en la primera parte declaramos nuestras variables, utilizando los diferentes tipos (char*, int, short int, unsigned short int, float) y luego sencillamente invocamos sus valores usando sus nombres donde queramos utilizarlas.

Ya que entendemos los diferentes tipos y su forma de declararse, no es tan intimidante o si?

GameStats

Para cerrar veamos la forma en la que todo el código se ve en conjunto:

#include <iostream>

void mostrarAtributosArma()
{
std::cout << "================== ATRIBUTOS DEL ARMA ==================" << std::endl;
std::cout << "Nombre: RW1" << std::endl;
std::cout << "Variante : Guardian" << std::endl;
std::cout << "Clase : Profesional" << std::endl;
std::cout << "Descripción : Arma de riel de mano, capaz de detener el combate.La mejor en su clase para causar daño" << std::endl;
std::cout << "Daño : " << 16 << std::endl;
std::cout << "Precisión : " << 7 + 1 << std::endl;
std::cout << "Cadencia de Fuego : " << 2 << std::endl;
std::cout << "Rango : " << 6 << std::endl;
std::cout << "Manejo : " << 7 - 1 << std::endl;
std::cout << "Movilidad : " << 12 << std::endl;
std::cout << "--------------------------------------------------------" << std::endl;
}

void mostrarFichaClan()
{
char* nombre = "ATLAS";
char* tag = "ATL";
char* lema = "El poder lo cambia todo";
int experienciaAcumulada = 90000;
int experienciaSiguienteNivel = 20000;
short int nivel = 11;
unsigned short int miembros = 13;
float relacionMuertesMuertos = 0.91f;
float relacionVictoriasDerrotas = 0.37f;

std::cout << "================== PERFIL DEL CLAN =====================" << std::endl;
std::cout << "Nombre : " << nombre << std::endl;
std::cout << "Tag : [" << tag << "]" << std::endl;
std::cout << "Lema : " << lema;
std::cout << "Estadísticas : " << std::endl;
std::cout << " - Nivel : " << nivel << std::endl;
std::cout << " - Experiencia Acumulada : " << experienciaAcumulada << std::endl;
std::cout << " - Experiencia para Siguiente Nivel : " << experienciaSiguienteNivel << std::endl;
std::cout << " - Miembros : " << miembros << std::endl;
std::cout << " - Relacion Muertes/Muertos : " << relacionMuertesMuertos << std::endl;
std::cout << " - Relacion Victorias/Derrotas : " << relacionVictoriasDerrotas << std::endl;
std::cout << "--------------------------------------------------------" << std::endl;
}

int main()
{
mostrarAtributosArma();
mostrarFichaClan();
return 0;
}


Con esto hemos concluido el código por ahora, quería implementar un par de conceptos adicionales (como las funciones que devuelven valor y funciones parametrizadas) en el ejercicio, pero he decidido que seria mezclar demasiadas cosas en un solo post por lo que por ahora lo dejaremos hasta acá. Pero no te preocupes que apenas vamos empezando el tutorial y aun nos quedan muchos ejercicios por hacer.

Como siempre espero haya sido de tu agrado y recuerda que cualquier comentario es bien recibido.

Hasta la próxima.

Anuncios
Esta entrada fue publicada en C++ y etiquetada , . Guarda el enlace permanente.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s