Tipo "int" o entero:

[signed|unsigned] [short|long] int <identificador>[,<identificador2>[,<identificador3>]...];
[signed|unsigned] long [int] <identificador>[,<identificador2>[,<identificador3>]...];
[signed|unsigned] short [int] <identificador>[,<identificador2>[,<identificador3>]...];

Las variables enteras almacenan números enteros dentro de los límites de cada uno de sus tamaños. A su vez, esos tamaños dependen de la plataforma, del compilador, y del número de bits que use por palabra de memoria: 8, 16, 32... No hay reglas fijas para saber el tamaño, y por lo tanto, el mayor número que podemos almacenar en cada tipo entero: short int, int o long int; depende en gran medida del compilador y del sistema operativo. Sólo podemos estar seguros de que el tamaño de un short int es menor o igual que el de un int, y éste a su vez es menor o igual que el de un long int. Veremos cómo averiguar estos valores cuando estudiemos los operadores.

A cierto nivel, podemos considerar los tipos char, short int, int y long int como tipos enteros diferentes. Pero esa diferencia consiste sólo en el tamaño del valor máximo que pueden contener, y en el tamaño que ocupan en memoria, claro.

Este tipo de variables es útil para almacenar números relativamente grandes, pero sin decimales, por ejemplo el dinero que tienes en el banco, (salvo que seas Bill Gates), o el número de lentejas que hay en un kilo de lentejas.

Tipo "long long":

[signed|unsigned] long long [int] <identificador>[,<identificador2>[,<identificador3>]...];

Este tipo no pertenece al estandar ANSI, sin embargo, está disponible en compiladores GNU, como el que se usa en Linux o el que usa el propio Dev-C++ (y otros entornos de desarrollo para Windows).

Este tipo ocupa el siguiente puesto en cuanto a tamaño, después de long int. Como en los otros casos, su tamaño no está definido, pero sí sabemos que será mayor o igual que el de long int.

Tipo "float" o coma flotante:

float <identificador>[,<identificador2>[,<identificador3>]...];

Las variables de este tipo almacenan números en formato de coma flotante, esto es, contienen un valor de mantisa y otro de exponente, que, para entendernos, codifican números con decimales.

Aunque el formato en que se almacenan estos números en un ordenador es binario, podemos ver cómo es posible almacenar números muy grandes o muy pequeños mediante dos enteros relativamente pequeños, usando potencias en base 10. Por ejemplo, tenemos para la mantisa un valor entero, m, entre -0.99 y 0.99, y para el exponente un valor, e entre -9 y 9.

Los números se interpretan como m x 10e.

Este formato nos permite almacenar números entre -0.99 x 109 y 0.99 x 109. Es decir, entre -990000000 y 99000000.

Y también números tan pequeños como 0.01 x 10-9 ó -0.01 x 10-9. Es decir, como 0,00000000001 ó -0,00000000001.

Esto sólo con tres dígitos decimales, más los signos. Pero en un ordenador se usa aritmética binaria. Por ejemplo, para un tipo float típico de 32 bits, se usa un bit de signo para la mantisa y otro para el exponente, siete bits para el exponente y 23 para la mantisa.

Para más detalles se puede consultar el siguiente enlace: representación de los números en punto flotante.

Estas variables son aptas para variables de tipo real, como por ejemplo el cambio entre euros y dólares. O para números muy grandes, como la producción mundial de trigo, contada en granos.

Pero el fuerte de estos números no es la precisión, sino el orden de magnitud, es decir lo grande o pequeño que es el número que codifica. Por ejemplo, la siguiente cadena de operaciones no dará el resultado correcto:

float a = 12335545621232154;
a = a + 1; 
a = a - 12335545621232154;

Finalmente, "a" valdrá 0 y no 1, como sería de esperar.

Los formatos en coma flotante sacrifican precisión en favor de tamaño. Sin embargo el ejemplo si funcionaría con números más pequeños. Esto hace que las variables de tipo float no sean muy adecuadas para todos los casos, como veremos más adelante.

Puede que te preguntes (alguien me lo ha preguntado), qué utilidad tiene algo tan impreciso. La respuesta es: aquella que tú, como programador, le encuentres. Te aseguro que float se usa muy a menudo. Por ejemplo, para trabajar con temperaturas, la precisión es suficiente para el margen de temperaturas que normalmente manejamos y para almacenar al menos tres decimales. Pero hay millones de otras situaciones en que resultan muy útiles.

Tipo "bool" o Booleano:

bool <identificador>[,<identificador2>[,<identificador3>]...];

Las variables de este tipo sólo pueden tomar dos valores true (verdadero) o false (falso). Sirven para evaluar expresiones lógicas. Este tipo de variables se puede usar para almacenar respuestas, por ejemplo: ¿Posees carné de conducir?. O para almacenar informaciones que sólo pueden tomar dos valores, por ejemplo: qué mano usas para escribir. En estos casos debemos acuñar una regla, en este ejemplo, podría ser diestro->true, zurdo->false.

bool respuesta;
bool continuar;

Nota: En algunos compiladores de C++ antiguos no existe el tipo bool. Lo lógico sería no usar esos compiladores, y conseguir uno más actual. Pero si esto no es posible, se puede simular este tipo a partir de un enumerado.

enum bool {false=0, true};

Tipo "double" o coma flotante de doble precisión:

[long] double <identificador>[,<identificador2>[,<identificador3>]...];

Las variables de este tipo almacenan números en formato de coma flotante, mantisa y exponente, al igual que float, pero usan una precisión mayor, a costa de usar más memoria, claro. Son aptos para variables de tipo real. Usaremos estas variables cuando trabajemos con números grandes, pero también necesitemos gran precisión. El mayor espacio para almacenar el número se usa tanto para ampliar el rango de la mantisa como el del exponente, de modo que no sólo se gana en precisión, sino también en tamaño.

Al igual que pasaba con los números enteros, no existe un tamaño predefinido para cada tipo en coma flotante. Lo que sí sabemos es que el tamaño de double es mayor o igual que el de float y el de long double mayor o igual que el de double.

Lo siento, pero no se me ocurre ahora ningún ejemplo en el que sea útil usar uno de estos tipos.

Bueno, también me han preguntado por qué no usar siempre double o long double y olvidarnos de float. La respuesta es que C++ siempre ha estado orientado a la economía de recursos, tanto en cuanto al uso de memoria como al uso de procesador. Si tu problema no requiere la precisión de un double o long double, ¿por qué derrochar recursos? Por ejemplo, en el compilador Dev-C++ float requiere 4 bytes, double 8 y long double 12, por lo tanto, para manejar un número en formato de long double se requiere el triple de memoria y el triple o más tiempo de procesador que para manejar un float.

Como programadores estamos en la obligación de no desperdiciar nuestros recursos, y mucho menos los recursos de nuestros clientes, para los que crearemos nuestros programas. C++ nos dan un gran control sobre estas características, es nuestra responsabilidad aprender a usarlo como es debido.

Tipo "void" o sin tipo:

void <identificador>[,<identificador2>[,<identificador3>]...];

En realidad esta sintaxis es errónea: no se pueden declarar variables de tipo void, ya que tal cosa no tiene sentido.

void es un tipo especial que indica la ausencia de tipo. Se usa para indicar el tipo del valor de retorno en funciones que no devuelven ningún valor, y también para indicar la ausencia de parámetros en funciones que no los requieren, (aunque este uso sólo es obligatorio en C, y opcional en C++), también se usará en la declaración de punteros genéricos, aunque esto lo veremos más adelante.

Las funciones que no devuelven valores parecen una contradicción. En lenguajes como Pascal, estas funciones se llaman procedimientos. Simplemente hacen su trabajo, y no revuelven valores. Por ejemplo, una función que se encargue de borrar la pantalla, no tienen nada que devolver, hace su trabajo y regresa. Lo mismo se aplica a las funciones sin parámetros de entrada, el mismo ejemplo de la función para borrar la pantalla no requiere ninguna entrada para poder realizar su cometido.

Tipo "enum" o enumerado:

enum [<identificador_de_enum>] {
   <nombre> [= <valor>], ...} <identificador>[,<identificador2>[,<identificador3>]...];
enum <identificador_de_enum> {
   <nombre> [= <valor>], ...} [<identificador>[,<identificador2>[,<identificador3>]...]];

Se trata de una sintaxis más elaborada que las que hemos visto hasta ahora, pero no te asustes, (si es que te ha asustado esto) cuando te acostumbres a ver este tipo de cosas comprobarás que son fáciles de comprender.

Este tipo nos permite definir conjuntos de constantes enteras, llamados datos de tipo enumerado. Las variables declaradas de este tipo sólo podrán tomar valores dentro del dominio definido en la declaración.

Vemos que hay dos sintaxis. En la primera, el identificador de tipo es opcional, y si lo usamos podremos declarar más variables del tipo enumerado en otras partes del programa:

[enum] <identificador_de_enum> <identificador>[,<identificador2>[,<identificador3>]...];

La segunda sintaxis nos permite añadir una lista de variables, también opcional.

De este modo podemos separar la definición del tipo enumerado de la declaración de variables de ese tipo:

enum orden {primero=1, segundo, tercero};
...
enum orden  id1, id2, id3;

O podemos hacer ambas cosas en la misma sentencia: definición y declaración:

enum orden {primero=1, segundo, tercero} id1, id2, id3;

Si decidimos no usar un identificador para el enumerado sólo podremos declarar variables en ese momento, y no en otros lugares del programa, ya que no será posible referenciarlo:

enum {primero=1, segundo, tercero} uno, dos;

Varios identificadores pueden tomar el mismo valor, pero cada identificador sólo puede usarse en un tipo enumerado. Por ejemplo:

enum tipohoras { una=1, dos, tres, cuatro, cinco, 
  seis, siete, ocho, nueve, diez, once, 
  doce, trece=1, catorce, quince, 
  dieciseis, diecisiete, dieciocho,
  diecinueve, veinte, ventiuna, 
  ventidos, ventitres, venticuatro = 0};

En este caso, una y trece valen 1, dos y catorce valen 2, etc. Y veinticuatro vale 0. Como se ve en el ejemplo, una vez se asigna un valor a un elemento de la lista, los siguientes toman valores correlativos. Si no se asigna ningún valor, el primer elemento tomará el valor 0.

Los nombres de las constantes pueden utilizarse en el programa, pero no pueden ser leídos ni escritos. Por ejemplo, si el programa en un momento determinado nos pregunta la hora, no podremos responder doce y esperar que se almacene su valor correspondiente. Del mismo modo, si tenemos una variable enumerada con el valor doce y la mostramos por pantalla, se mostrará 12, no doce. Deben considerarse como "etiquetas" que sustituyen a enteros, y que hacen más comprensibles los programas. Insisto en que internamente, para el compilador, sólo son enteros, en el rango de valores válidos definidos en cada enum.

La lista de valores entre las llaves definen lo que se denomina el "dominio" del tipo enumerado. Un dominio es un conjunto de valores posibles para un dato. Una variable del tipo enumerado no podrá tomar jamás un valor fuera del dominio.

Palabras reservadas usadas en este capítulo

Las palabras reservadas son palabras propias del lenguaje de programación. Están reservadas en el sentido de que no podemos usarlas como identificadores de variables o de funciones.

char, int, float, double, bool, void, enum, unsigned, signed, long, short, true y false.

Comentarios de los usuarios (55)

Melon
2009-12-23 15:25:03
new a = 5; b = 6

a = a+b
No es lo mismo que poner:
¿ a += b ?
Mauricio
2010-02-15 19:21:56

Hola quisiera sugerir mas ejemplos a la hora de explicar conceptos especificos. gracias

bmcemg
2010-02-17 09:42:26

+= es un Operador de asignación,en a+=b entonces estarias asignando a (a) el resultado de a+b y pues por lo que veo si es lo mismo que poner a = a+b ya que lleva a cabo la misma tarea.

Bruno
2010-03-19 02:13:50

Por lo que yo conozco en Java sí es lo mismo escribir a=a+b que a+=b, de cualquiera de las dos maneras a (a) le esta asignado la suma de si mismo con (b), o sea que le suma (b) y se asigna este nuevo resultado a la variable (a) -que es lo que pasa en este ejemplo-, pero en C++ todavia no conozco si funciona de la misma manera la adición y asignación.

caremao
2010-05-31 05:21:58

Sería sumamente útil mostrar antes que las variables y demás, como mostrar salidas así sea compilando por consola. Un código en C funcional que nos permitiera escribir variables en consola.

Gabi
2010-11-28 19:28:43

En las variables tipo double, dices que no se te ocurre ningún ejemplo. Une ejemplo de una serie de datos que sean precisos y muy grandes, por ejemplo, en el campo de la investigación espacial, a la hora de establecer teorías acerca del movimiento de los astros, las distancias son sumamente grandes (del orden de 1 año luz) mientras que las velocidades o los radios no lo son tanto.

Paco
2011-05-22 20:23:59

Excelente curso; soy principiante y aún aunque no conozco a ciencia cierta todos los conceptos que maneja el autor (autores), la forma en que está explicado es bastante fluida y entendible.

Gracias.

Raquel
2011-07-21 14:00:12

Hola que tal??? estoy empezando el curso y me gustaria saber que diferencia hay entre char *num y char num para que sirve uno y otro se que el segundo lee caracteres pero el primero???

Bueno muchas gracias a los creadores de esta pagina

Un saludo

diego
2011-07-24 06:23:09

Raquel disculpa pero te aclaro que char*num es un puntero de tipo char y char num es una declaracion de una variable del tipo char, lo que quiero decir que char*num es para trabajar directamente con las direcciones de memoria, creo que mas adelante se explica eso, pues yo estoy empezando este curso igual pero ya sabia programas en c y el uso de punteros(estructuras de datos que igual esta en esta pagina). espero que hayas entendido

juan Carlor
2011-08-09 02:38:54

woooooooooo

me gusta tu programa

realmente me ayuda mucho

gracias por subirlo

javiol
2012-01-17 12:06:09

Me parece que está muy bien explicado y además con bastante profundidad. Yo conozco bastante bastante bien C pero C++ menos, y quería aprender y este sitio me ha parecido el mejor.

Tengo una pregunta, según tengo entendido en C++ no es necesario volver a escribir enum al decalrar nuevas variables del enum ya definido. Eso es cierto? Es que en el ejemplo que declarar un enum orden{...} como tipo luego para declarar las variables concretas hay que volver a poner enum??? (en C se que si pero en C++ )

Muchas gracias por el curso, y enhorabuena

Steven R. Davidson
2012-01-17 12:34:55

Hola Javiol,

Muchas gracias. Intentamos que sirva para todos.

No. En C++, muchas de las entidades que creas, no requieren que indiques qué son, como es el caso de 'enum'. Tampoco se necesita indicar 'struct' a una estructura que ya definiste previamente. Por ejemplo,

struct persona
{
  char szNombre[128];
  char szApellidos[256];
};

int main()
{
  persona per = { "Pepe", "Bodoque de la Sierra" };

  return 0;
}

No es necesario indicar 'struct persona', porque C++ entiende que 'persona' se refiere a una estructura, la cual fue previamente definida.

Espero haber aclarado la duda.

Steven

javiol
2012-01-17 20:51:22

Muchisimas gracias, ademas del buen contenido, contestias preguntas.. y rápido!!!

Ya entonces no me queda duda... lo que pasa es que en el ejemplo que pones dentro de la parte del curso de tipo enum, si te fijas declarais el tipo enum orden{uno, dos...} y luego declarais las variables id1,id2 poniendo enum orden id1, id2..; con enum delante y eso me despistó respecto a lo que tenía entendido que en C++ los enum son un nuevo tipo de dato.

Muchas gracias de nuevo

Espontani
2012-02-19 12:02:43

Javiol,

Solo añadir un detalle sobre los tipos enum:

Muchas veces, en el código fuente se puede ver la sintaxis

typedef enum {
    EMPLEADO,
    ESTUDIANTE
} tipoPersona;

Esta técnica se usa para no tener que añadir la palabra clave enum cada vez que se declara una variable tipoPersona en C. En C++, como apunta Steven R. Davidson no es necesario.

Espontani
2012-02-19 12:16:32

Steven R. Davidson,

Hay un matiz en cuanto a los enumerados que no se contempla en la explicación, que es el rango de los mismos.

El rango de valores que puede contener un enumerado, si se usan números positivos, va desde el cero hasta el valor máximo que quepa en la cantidad mínima de bits necesaria para contener el valor de la constante más grande definida en el enumerado, ejemplo:

typedef enum {
	PERRO, // = 0, en binario 0
	GATO, // = 1, en binario 1
	ORNITORRINCO // = 2, en binario 10
} animalType;

Por tanto los valores posibles són: 00, 01, 10 y, como por fuerza harán falta mínimo 2 bits para albergar 10, el valor 11 también és válido. El 110 por ejemplo no.

#include <iostream>

typedef enum {
	PERRO,
	GATO,
	ORNITORRINCO
} animalType;

int main (int argc, char **argv) {
	animalType animal=animalType(3); //Correcto binario 11
	animalType animal2=GATO; //Correcto
	animalType animal3=animalType(2598664568); //Error, comportamiento indefinido
	
	std::cout << animal << std::endl;
	std::cout << animal2 << std::endl;
	std::cout << animal3 << std::endl;
	
	return 0;
}
Calculin
2012-04-08 06:03:54

Excelente curso.

Hago un pequeño aporte. Si escribimos:

enum orden_1 {uno=1, dos, tres};
enum orden_2 {uno=1, dos, tres};

nos da un error de compilacion porque en orden_2 estamos

repitiendo los nombres: uno, dos y tres.

Manuel
2012-11-15 16:50:44

Hola, estoy usando Code::blocks 10.5 con c++ en vista64 bits y al examinar las variables reales me encuentro con que tienen la misma precisión:

float a = 3.14159f;

double b = 3.14159265358979;

long double c = 3.141592655358979;

al hacer un cout me sale 3.14159 en las tres variables.

De hecho me pasa también con int y long int que solo me almacena 32 bits. ¿Es cuestión del compilador que tenga instalado (creo que es GNU GCC compiler) o se debe a otra cosa?

Steven R. Davidson
2012-11-15 18:31:22

Hola Manuel,

En cuanto a los tipos de coma flotante, el resultado que aparece en pantalla se debe realmente al formato que aplica 'cout'. Si quieres más dígitos significativos, entonces tienes que "configurar" 'cout' para que los muestre, que por defecto, son 6. Por ejemplo,

cout.precision( 10 );
cout << a << ' ' << b << ' ' << c << endl;

También puedes usar el manipulador de canales, 'setprecision()', definido en <iomanip>. Esto sería,

cout << setprecision( 10 ) << a << ' ' << b << ' ' << c << endl;

En cuanto al tamaño que ocupa cualquier variable de los tipos de datos, esto sí tiene que ver con el compilador. Si quieres usar un tipo de entero de 64 bits, entonces usa 'long long int'. La otra solución es usar los tipos definidos en la biblioteca estándar, en el fichero de cabecera, <cstdint>. Por ejemplo,

int32_t n;
int64_t m;
...

Espero que esto aclare las dudas.

Steven

Manuel
2012-11-15 20:50:00

Pues muchas gracias Steven por una respuesta tan rápida y precisa. Me ha aclarado mucho las dudas y el tipo int64_t es una solución válida para sustituir el tipo largo de entero :)

Halther Payano
2013-01-08 18:31:08

Creo que todo me quedo más o menos claro, lo que no entendí bien fue lo de el tipo num. Si alguien puede explicarme el num de una manera más fácil por favor? Lo que yo entendí acerca de el float es que se utiliza para programar calculos de decimales o cifras en notación cientifica. No sé pero pienso que empiezo a enredarme, ayuda.

Halther Payano
2013-01-08 18:37:25

Una pregunta, es necesario que ya tenga en manos el compilador? Yo descarge el code:: block 10.05 aunque no tengo ni idea de como empezar a usarlo.Otro detalle que me gustaría saber es, si estas explicaciones serán las unicas o habrán otras explicaciones en cuanto a la hora de empezar a programar a lo largo del curso. Osea mi pregunta es por ejemplo : Habrán otras explicacion que te hiran explicando el por qué no debes hacer x cosa que ya hallas leido?

Salvador Pozo
2013-01-08 19:19:35

Hola, Halther:

Supongo que te refieres al tipo "enum", no "num".

Los tipos enumerados se usan para crear tipos con un número finito y generalmente pequeño de valores posibles.

No es posible realizar operaciones aritméticas con estos tipos, son como conjuntos, y tan sólo se usan para que el código quede más claro y para impedir que determinadas variables puedan tomar valores prohibidos.

Por ejemplo, si un tipo enum lo vamos a usar para contener valores de nombres de dedos, podría quedar así:

enum dedos { pulgar, indice, corazon, anular, menique };

En el programa sólo podremos asignar a una variable de tipo dedos uno de los valores del enum, y ningún otro.

Internamente esos valores son números enteros, pero generalmente eso no nos importará demasiado, ya que sólo usaremos los valores definidos en el programa, de modo que sea más fácil de leer y que sea imposible asignar valores que no existen.

Los float y los double se usan en cálculos con decimales, en cualquier ocasión en que sea necesario. No tiene por qué ser en notación científica, aunque existe esa opción.

Muchas funciones matemáticas sólo admiten y devuelven valores de estos tipos.

Salvador Pozo
2013-01-08 19:32:22

Hola, Halther:

Es conveniente disponer de un compilador, sobre todo porque la programación se perfecciona practicando, y para practicar necesitarás escribir, compilar y ejecutar tus programas.

Si nunca ha usado un IDE, como Code::Blocks, entiendo que no sepas por dónde empezar, pero piensa que sería más difícil si no dispusieras de un IDE y tuvieras que hacerlo todo usando comandos de consola. :)

No te preocupes mucho, estamos aquí para ayudar. Nos gustaría hacer algún video sobre algunos temas, sobre todo sobre el uso del IDE, pero no te puedo decir cuando podremos hacerlo.

Si tienes dudas a ese respecto, te recomiendo que acudas a la lista de correo:

http://listas.conclase.net/?gid=2

La segunda parte de la pregunta no la entiendo bien. A lo largo del curso se van introduciendo nuevos conceptos en cada capítulo, de una forma progresiva, y hemos intentado que la progresión sea suave, aunque no siempre es fácil y a veces no lo hemos logrado del todo.

Apenas estamos en el segundo capítulo (de 43), y hasta el sexto no se empiezan a ver ejemplos completos. En los primeros capítulos es necesario introducir más teoría, hasta conocer algunas piezas indispensables en cualquier programa C++, pero no te desanimes, hay muchas explicaciones, tanto en este curso como en otros, y siempre puedes preguntarnos tus dudas.

Halther Payano
2013-01-08 19:43:51

Muchas grascias Salvador Pozo Coronado, me ha quedado un poco claro tu explicación. Estaré esperando ese vídeo ya que tengo el programa, pero ni idea de donde se escriben los codigos y cuales son los pasos para crear el ejecutable. Yo voy a leer todo de nuevo porque siento que no me queda claro del todo por la emoción de crear algo . Nuevamente gracias y espero aprender mucho aquí ya que creo que me queda algo así como un año para entrar a la carrera de sistema y quiero tener todo eso claro antes de entrar.

Borja
2013-01-11 20:47:41

Tengo una duda con las variables enum: ¿Se pueden realizar operaciones aritméticas o de incremento con ellas? En caso afirmativo, ¿cuál sería el efecto?

damian
2013-01-15 17:15:39

Tengo una duda, cada vez que intento poner una funcion en mi code::blocks me dice esto "Undefined reference to WinMain @16" . Hasta intente con funciones verdaderas como las que ponen aca.

Steven R. Davidson
2013-01-15 18:19:50

Hola Borja,

Sí puedes usar operadores aritméticos con entidades de tipo enumerado. Al fin y al cabo, se trata de valores enteros. Por ejemplo,

enum color_t { ROJO=1, NARANJA, AZUL, MARRON };

color_t color = ROJO;
color++;

Ahora 'color' guarda el valor de 2, el cual representa 'NARANJA'.

Como puedes ver, se puede hacer esto, pero la pregunta sería: ¿qué significa "incrementar rojo"? Es decir, desde un punto de vista de diseño, quizás esto no tenga mucho sentido, pero el lenguaje no tiene ningún problema.

Tengo que agregar que en el nuevo estándar de C++, los tipos enumerados no son implícitamente convertidos a enteros. Por lo tanto, no se pueden hacer comparaciones implícitas con enteros; por ejemplo,

if( NARANJA == 2 ) ...  // Da error en el nuevo estándar

Espero haber aclarado la duda.

Steven

Steven R. Davidson
2013-01-15 18:27:50

Hola Damián,

El problema es que has creado un proyecto de aplicaciones (GUI) para MS-Windows, por lo que intenta buscar la función 'WinMain()', pero no la encuentra.

Otro caso es que no has creado ningún proyecto y meramente compilaste el código fuente. Por defecto, Code::Blocks crea un proyecto para MS-Windows. Por esta razón, aconsejamos crear SIEMPRE un proyecto, si usas un IDE, como es Code::Blocks, por muy simple que sea tu programa.

Espero que esto te oriente.

Steven

damian
2013-01-15 23:28:38

Perdon pero no te entendi, lo que hice fue :

File<new<project . Me aparecieron varias opciones, de todas ellas, eleji Console application. Despues me pidio el nombre del compilador y puse GNU GCC Compiler .

Abri el proyecto copie esto que lei en unos comentarios

typedef enum {

EMPLEADO,

ESTUDIANTE

} tipoPersona;

Clickie en Build y me aparecio detected 1 error undefined reference to WinMain@16 .

Perdon por no entenderte el comentario es que es la primera vez que hago un curso de programacion y gracias por responder tan rapido.

Steven R. Davidson
2013-01-16 00:57:04

Hola Damián,

El problema es que no has terminado de escribir el programa. Principalmente, necesitas definir la función 'main()'. Miraremos la forma de escribir programas completos, en el capítulo 6.

Hasta pronto,

Steven

damian
2013-01-16 02:24:13

Steven,

La verdad es que me has sido de gran ayuda y muchisimas gracias por responder mis preguntas tan rapidamente. Esto no se si sea una pregunta pero es una duda, tengo 15 años y nunca he usado un lenguaje de programacion, se puede empezar por c++ o tengo que empezar con uno mas basico como es el Pascal. Porque los ejercisios del capitulo 3 no me salieron y desde el final de este capitulo tuve muchos problemas. quizas sea porque le dedique poco tiempo (2 dias) pero la verdad es que no se que es lo que pasa.

Responde cuando puedas, no es necesario que contestes forzadamente tan rapido.

Saludos, damian

Steven R. Davidson
2013-01-16 03:03:35

Hola Damián,

La verdad es que Pascal no es tan diferente a C/C++, así que no vas a tener una gran ventaja en empezar por ello. Es cierto que C/C++ son lenguajes que requieren más tiempo para el aprendizaje comparados con otros lenguajes de programación. Sin embargo, merece la pena aprender C++, ya que la gran mayoría de los lenguajes será muy fácil de aprender, una vez que sepas C++.

Si necesitas más tiempo para dedicar a aprender C++, hazlo. Si tienes dudas, plantéalas en nuestra lista de correo-e, ya que dispondrás de la ayuda de miles de socios.

Como mencioné antes, al final del capítulo 6, veremos ejemplos con códigos fuente completos. Mi recomendación es que intentes llegar al final del capítulo 6, si necesitas ver cómo todos los temas se reúnen y se usan para escribir un programa completo. Por ahora, los primeros capítulos darán su temática justa para entender los conceptos y conocer la sintaxis de los vocablos del lenguaje.

Espero que esto te oriente.

Steven

damian
2013-01-16 03:32:43

Muchisimas gracias por responder, ahora le estoy encontrando mas vueltas al tema, es que pensaba que la funcion era solo

[signed|unsigned] char <identificador>, y no entendia mucho recien ahora empiezo a saber que todo esto se va a unir y formar una funcion. Sos realmente colaborador con la gente que lee este curso y ahora voy a ponerle mucha mas pila.

Muchisimas gracias y saludos,

damian

Juan Carlos Mesillas
2013-02-21 00:01:18

Hola que tal soy nuevo en esto de programar en c, y estoy haciendo un programa que me diga mi signo zodiacal, el problema es que estoy haciendolo para que no tenga ningun error como por ejemplo si ingreso dias o meses negativos, o dias mayores a 31 etc, lo hago condicionando mis variables mi problema es que solo me falta hacerlo para un error con numeros decimales como seria solo uso if.

Salvador Pozo
2013-02-25 17:09:07

Hola Juan Carlos:

Si se trata de fechas, no entiendo por qué tienes que validar resultados para evitar valores con decimales. Yo usaría variables enteras, de ese modo no hay posibilidad de que el usuario introduzca valores en coma flotante.

Murdocdng
2013-02-26 23:05:38

Soy yo o hay un error con los tipos de variables? Es que cuando quiero pasar a Tipo "int" o entero, me aparece que no se encuentra el texto, y así con todas.

Gracias!

Gustavo Fabian
2013-02-27 01:35:09

Si, evidentemente hay un problema con el capitulo 2.

Solo se ve el texto del Tipo char, luego los demás (del capitulo 2) aparecen como "Texto no encontrado".

Espero lo solucionen.

Gustavo

Salvador Pozo
2013-02-27 13:44:18

Hola:

Ya he solucionado el problema con el capítulo 2, disculpad por las molestias.

Hasta pronto.

Gustavo F. Paredes
2013-02-27 15:14:21

Al contrario.

Gracias a ti por resolverlo tan rapidamente.

Gustavo

Víctor
2013-07-17 12:01:46

Hola, es una tontería que me he dado cuenta según leía el apartado de las variables tipo float, cuando especificas la capacidad de números que este tipo de variable puede contener:

"Este formato nos permite almacenar números entre -0.99 x 10^9 y 0.99 x 10^9. Es decir, entre -990000000 y 99000000."

Hay un error, ya que falta un cero en 990000000 (7 ceros y sólo aparecen 6)

Ya dije que era una tontería, pero todo sea por ayudar a corregir cualquier desliz en esta genial página. Gracias por todo el trabajo que has depositado aquí, a mi personalmente me está ayudando bastante =)

ed lee
2013-11-08 13:40:27

compas. como le hago para que las respuestas de una operacion matematica No salgan con exponentes, por ejemplo 2.5e+012... soy aprendiz y quiciera saber como le hago para evitar ese tipo de respuestas

Steven R. Davidson
2013-11-08 17:22:11

Hola Ed Lee,

Tienes que configurar 'cout' para que muestre los números de coma flotante en formato "fijo". Puedes hacer esto:

cout.setf( ios::fixed, ios::floatfield );

cout << 2.5e+012 << endl;

Aparecerá en pantalla:

2500000000000.000000

También puedes usar el manipulador de canales, 'fixed'; esto es,

cout << fixed << 2.5e+012 << endl;

Espero que esto te ayude.

Steven

Miko
2014-06-01 17:26:51

Muy Bueno, pero lastima que no ando bien para matematicas, pero esto me insentiva a Progresar y seguir aprendiendo, asi que dare un pequeño pause y mas matematicas y luego seguire esta marabillosa clase!

eddy
2015-01-14 19:34:48

hola muy bueno este stio he aprendido mucho gracias a este curso de C++

iglbyn
2015-09-21 12:09:05

Hola queria apuntar que desde C++11 (al menos eso creo) se puede especificar el tipo de dato de las enums, por ejemplo:

enum TiempoMillis : long {SEGUNDOS = 1000L, MINUTOS = 60000L}

No se si estaba ya explicado en este curso, lo he buscado y no lo he visto, Saludos.

leandro
2015-09-21 23:24:29

Cuando compilo y ejecuto este programa me aparece este mensaje en DevC++: Error ID returned 1 exit status

#include

using namespace std;

int main ()

{

int num;

cout << "Introduce un valor: ";

cin >> num;

cout << "El valor de la variable es:" << num << endl;

system ("pause");

}

Gracias de antemano :)

Steven R. Davidson
2015-09-28 06:33:19

Hola Iglbyn,

Efectivamente, a partir de C++11, las definiciones de los tipos enumerados refuerzan la tipificación.

Por ahora, el curso de C++ es anterior al 2.011, mientras lo actualizamos.

Steven

iglbyn
2015-09-29 14:11:54

Hola Steve, Solo queria dejarlo apuntado para quien le pudiera servir de ayuda.

Y felicitarle por tan excelente trabajo, que es de gran ayuda y muy bien explicado.

iglbyn
2015-10-01 11:24:14

Perdon Steven, que me precipite al escribir y me comi una n.

andres
2015-10-31 20:21:06

cual seria la declaracion apropiada para una variable entera inicializada en 10

Adrian
2016-09-25 01:19:52

Tengo una enumeración como esta:

enum enumeracion{a,b,c,d,e,f,g,h,i,j,k,l};

Y despues tengo algo como esto:

enum enumeracion c = c;

Curiosamente no me da error de compilación por ambigüedad.

¿Como puedo decirle que la c de la derecha es la que esta dentro de la enumeracion y no esa misma c?

Adrian
2016-09-25 01:40:31

Acabo de descubrir algo interesante que puedes añadir en tu tutorial sobre los enum:

Desde la 'e' de "enum" hasta el cierre de llaves '}' se puede considerar un tipo y, por lo tanto, usarse para declarar no solo variables de tal tipo, sino tambien para instanciarlas en la misma sentencia y usar modificadores tales como "const" usando la sintaxis de declaracion de tipos, solo que teniendo en cuenta que el tipo se considera que es desde la 'e' de "enum" hasta, en caso de tener tambien la definicion, el cierre de llaves '}'.

Ejemplos:

const enum enumeracion{a,b,c,d,e,f,g,h,i,j,k,l}enum1 = g;

enum enumeracion{a,b,c,d,e,f,g,h,i,j,k,l} enum2 = d,*enum3 = &enum2;

Pero si vas a hacer una funcion, no puedes definir el tipo del enum directamente en el parametro, ya que eso nisiquiera tiene sentido.

erick
2017-03-02 19:09:32

buen dia quisiera saber si me pudieran ayudar, como puedo hacer un programa con funciones de usuario que me permita administrar la venta de boletos en una dimensión de 8 filas x20 columnas el programa deberá verificar la disponibilidad del asiento a vender enviando un mensaje de "boleto vendido" o "boleto reservado" el programa debe considerar la venta múltiple de boletos así como considerar que una vez iniciada la venta todos los lugares estén disponibles me pide también que ilustre en la pantalla los lugares ocupados con 1 o 0 dependiendo su estado

Program_Amateur
2017-03-26 01:46:00

Tengo Problemas al leer las variables, no toman el valor que quiero. agradeceria su ayuda

#include <conio.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

main()

{

float r1 = 0,r2 = 0,r3 = 0;

float resul;

float res1,res2,res3;

printf("Ingrese el valor de la Resistencia 1: ");

scanf("%d",&r1);

printf("Ingrese el valor de la Resistencia 2: ");

scanf("%i",&r2);

printf("Ingrese el valor de la Resistencia 3: ");

scanf("%d",&r3);

res1= 1/r1;

res2= 1/r2;

res3= 1/r3;

resul= 1*(res1+res2+res3);

printf("El Resultado es: %e .\n", &resul);

system("PAUSE");

return 0;

}

IntentarAprender
2017-08-15 12:06:16

Buenas! Cómo podría hacer para introducir un número entero demasiado largo en una cadena de caracteres??

Mi código es el siguiente:

int numCifras (int n){

int cuenta = 0;

if(n<10){ //caso base

return 1;

}else{

while(n!=00){

n = n/10;

cuenta++;

}

}

return cuenta;

}

void convertir (const int n, char sec[]){

int nDIG = numCifras(n); //numero de digitos de n

int auxiliar = n; //como la n es constante necesitamos

//variable auxiliar para poder modificar

if(n == 0){ //Caso base

sec[0] = '0' + 0;

sec[1] = '\0';

}else{

//Para pasa un entero a una cadena de caracteres tenemos que hacer

//'0' + cadena de caracteres

for(int i = nDIG - 1; i>=0; i--){

sec[i] = '0' + auxiliar % 10;

auxiliar = auxiliar/10;

}

//En la posicion del numero de cifras de n tenemos que poner el

//caracter nulo '\0' como lo especifica en la post.

sec[nDIG] = '\0';

}

}

Mi duda es que no se cómo hacer para cortar un numero entero demasiado grande y no haya overflow...

Es decir, para 12345678934 cómo se puede almacenar en sec?

No me dejan hacer uso de punteros.

Muchas gracias!