Programación en

C++/Lo más básico

< Programación en C++

← Iteraciones y decisiones
Introduccion →

Estructura de un programa

En general, los programas escritos en

C++ tienen una estructura (básica)
compuesta por tres secciones:

1. Directivas de preprocesador
2. declaraciones globales
3. declaración de funciones

Directivas de preprocesador

Los compiladores de C++

proporcionan bibliotecas de
funciones, y cada biblioteca de
funciones tiene asociada un archivo
de definición que se denomina
cabecera. Para utilizar algo de una
biblioteca en un programa (por
ejemplo, una función), hay que
colocar al principio del programa una
directiva de preprocesamiento
seguida de la cabecera de la
biblioteca entre signos de "menor
que" y "mayor que" (<>).

A continuación se muestra un típico

ejemplo de una directiva de
preprocesador:

#include <iostream>

En el ejemplo anterior, la directiva

invocada es include y la cabecera
iostream, e indican al preprocesador
que debe incluir la librería iostream a
nuestro programa. Cabe señalar que
todas las directivas comienzan con el
símbolo numeral #. Dentro de las
directivas de preprocesador se
encuentran:

1. Macros de preprocesador
(#define y #undef)
2. Inclusiones condicionales
(#ifdef, #ifndef, #if, #endif, #else
and #elif)
3. Control (#line)
4. Error (#error)
5. Inclusión de fichero (#include)
6. Pragma (#pragma)
Macros de preprocesador

Para definir macros de

preprocesador, usamos la directiva
#define. La sintaxis es:

#define identificador reemplazo

Cuando el procesador encuentra esta

directiva, este reemplaza todas las
ocurrencias del identificador y son
sustituidas por reemplazo. Cuando
se requiere desactivar una macro, a
partir de cierta parte del código, se
utiliza la directiva #undef. La sintaxis
es:
#undef nombre_macro

Inclusiones condicionales

Estas directivas permiten incluir o

descartar partes de código, si se
cumplen algunas condiciones.

#ifdef: Permite que una sección del

programa sea compilada solo si la
macro especificada como
parámetro ha sido definida, sin
importar el valor de esta. Por
ejemplo:
#ifdef TABLE_SIZE
int table[TABLE_SIZE];
#endif
El ejemplo anterior indica que, si la
macro TABLE_SIZE se encuentra
definida, entonces procede a la
creación de una matriz de enteros de
tamaño TABLE_SIZE. Cabe señalar
que el fin para esta directiva es la
directiva #endif

#ifndef: Permite realizar

exactamente todo lo contrario a
#ifdef. La lineas de código que se
encuentren entre #ifndef y #endif,
serán ejecutadas siempre y cuando
la macro señalada como
parámetro de #ifndef no se
 encuentre definida aun. Por
ejemplo:
#ifndef TABLE_SIZE
#define TABLE_SIZE 100
#endif
int table[TABLE_SIZE];

En el ejemplo anterior, se indica que

si la macro TABLE_SIZE no está
definida aún, entonces se define.
Cabe señalar que el fin para la
directiva #ifndef es, al igual que
#ifdef, #endif.

#if, #else y #elif (o else if): Estas

directivas tienen el mismo
significado que los comandos
condicionales de cualquier
 lenguaje de programación. Por
ejemplo:
#if TABLE_SIZE>200
#undef TABLE_SIZE
#define TABLE_SIZE 200

#elif TABLE_SIZE<50
#undef TABLE_SIZE
#define TABLE_SIZE 50

#else
#undef TABLE_SIZE
#define TABLE_SIZE 100
#endif

int table[TABLE_SIZE];

En el ejemplo anterior, se muestra el

uso de todas las directivas
condicionales del preprocesador.

Control

Cuando compilamos un programa y

un error ocurre durante el proceso de
compilación, el compilador muestra
un mensaje de error con las
referencias al nombre del archivo
donde ocurrió el error y un número de
línea, por lo que es más fácil
encontrar el código que genera el
error. La directiva #line nos permite
controlar ambas cosas, los números
de línea en los archivos de código, así
como el nombre del archivo que
queremos que aparece cuando un
error ocurre. Su formato es:

#line numero "nombre_de_archivo"

Donde número es el nuevo número de

línea que se asignará a la siguiente
línea de código. Los números de línea
de las líneas sucesivas se
incrementarán uno por uno desde
este punto en
adelante."nombre_de_archivo" es un
parámetro opcional que permite
redefinir el nombre del archivo que se
mostrará. Por ejemplo:

#line 20 "asignacion de variable"

int a?;

Este código generará un error que se

mostrará como un error en el archivo
de "asignación de variable", línea 20.
Error

Esta directiva cancela la compilación

cuando es encontrada, generando un
error de compilación que puede ser
especificado según un parámetro de
un ejercicio. Por ejemplo:

#ifndefcplusplus
#error A Se requiere compilador de C++
#endif

En el ejemplo anterior, la compilación

es cancelada si la macro __cplusplus
no está definida (Esta macro es
definida por defecto en todos los los
compiladores de C++).
Inclusión de fichero

Cuando el preprocesador encuentra

la directiva #include, este reemplaza
todas las ocurrencias de ella por el
archivo o cabecera especificada.
Existen dos formas de utilizar
#include:

#include <cabecera>: Es usado

para incluir las cabeceras
proporcionadas por defecto, por
ejemplo, la librería estándar (string,
iostream, etc.).
#include "archivo"  : Es usado para
incluir archivos.
Pragma

La directiva #pragma es utilizada

para especificar las distintas
opciones del compilador. Estas
opciones son especificadas
dependiendo del compilador que se
utilice. Si el compilador no permite un
argumento para #pragma, esto es
ignorado y no genera un error de
sintaxis.

Declaraciones globales

En esta sección se declaran todas

variables y cabeceras de funciones
que seran vistas de manera global, es
decir, que su alcance es total en el
programa. Por ejemplo:

#include <iostream>
#define PI 3.1415

std::string autor: "Wikibooks";

int adicion(int, int);

En el ejemplo anterior, se definen

(ademas de las directivas de
preprocesador, vistas en la sección
anterior) una variable y una función.
La variable autor podrá ser utilizada
por todas las funciones del
programa. Mientras que la función
"adicion" solo fue declarada de la
forma "inline". Una función se dice
declarada "inline" cuando solo se
señala su nombre y sus tipos de
entrada y salida. Su definición
completa se reserva para mas
adelante.

Declaración de funciones

La ultima sección del programa es la

declaración de funciones. La primera
función que se debe declarar es la
función principal o "main". La función
main es la mas importante, pues es
la que es invocada cuando el
programa se ejecuta. Toda
instrucción que no sea declarada
dentro de esta, simplemente no sera
considerada. A continuación de la
función "main", se permite la
definición completa de las funciones
declaradas en la sección de
declaraciones globales. En el
siguiente ejemplo, mostraremos la
estructura definitiva de un programa
y la declaración completa de sus
funciones:

#include <iostream>
#define PI 3.1415

std::string autor= "Wikibooks";

int adicion(int, int);

int main(int argc, char **argv)

{
std::cout<<"El resultado de la suma de 1 y 2 es "<<adicion(1,2)
<<std::endl;
return 0;
}
int adicion(int a, int b)
{
return a+b;
}

Los parámetros de entrada de la

función main es algo que se abordará
mas adelante.

Proceso de desarrollo de
un programa

Si se desea escribir un programa en

C++ se debe ejecutar como mínimo
los siguientes pasos:

1. Escribir con un editor de texto

plano un programa
sintácticamente válido o usar un
 entorno de desarrollo (IDE)
apropiado para tal fin
2. Compilar el programa y
asegurarse de que no han
habido errores de compilación
3. Ejecutar el programa y
comprobar que no hay errores
de ejecución

Este último paso es el más costoso,

por que en programas grandes,
averiguar si hay o no un fallo
prácticamente puede ser una tarea
totémica.
Como ejemplo, si se desea escribir
un archivo con el nombre hola.cpp y
en él escribir un programa con
emacs, por ejemplo, que es un
programa de edición de textos, se
puede, en GNU, ejecutar el siguiente
comando:

$emacs hola.cpp &

Para otros sistemas operativos u

otros entornos de desarrollo, no
necesariamente se sigue este paso.

A continuación se escribe el siguiente

código en C++:
Ejemplo

// Aquí generalmente se suele indicar qué se quiere con el

programa a hacer
// Programa que muestra 'Hola mundo' por pantalla y finaliza

// Aquí se sitúan todas las librerias que se vayan a usar con

#include,
// que se verá posteriormente
// Las librerias del sistema son las siguientes
#include <iostream>

// Función main
// Recibe: void
// Devuelve: int
// Función principal, encargada de mostrar "Hola Mundo",por
pantalla

int main(void)
{
// Este tipo de líneas de código que comienzan por '//' son
comentarios
// El compilador los omite, y sirven para ayudar a otros
programadores o
// a uno mismo en caso de volver a revisar el código
// Es una práctica sana poner comentarios donde se necesiten,

std::cout << "Hola Mundo" << std::endl;

// Mostrar por std::cout el mensaje Hola Mundo y comienza una

nueva línea

return 0;

// se devuelve un 0.
//que en este caso quiere decir que la salida se ha efectuado
con éxito.
}

Mediante simple inspección, el

código parece enorme, pero el
compilador lo único que leerá para la
creación del programa es lo
siguiente:
Ejemplo

#include <iostream>
int main(void){ std::cout << "Hola Mundo" << std::endl; return 0;
}

Como se puede observar, este código

y el original no difieren en mucho
salvo en los saltos de línea y que los
comentarios, de los que se detallan
posteriormente, están omitidos y tan
sólo ha quedado "el esqueleto" del
código legible para el compilador.
Para el compilador, todo lo demás,
sobra.

O este otro, que es, en parte, como el

lenguaje C, en su versión C99, es:
Ejemplo

#include <stdio.h>
#include <stdlib.h>
int main(void)
{
printf( "Hola Mundo\n" );
return EXIT_SUCCESS;
// 'EXIT_SUCCESS' es una definición que está dentro de 'stdlib.h'
// también funciona return 0
}

Nota: si se usa Windows, el código es

el mismo, pero debemos agregar un
método más para que el programa se
mantenga abierto y no se cierre la
consola, cosa que en GNU, no es
necesaria por que la consola ya esta
abierta (al mandar a ejecutar).

Para esto podemos usar cin.get() que

nos permitirá leer del teclado, por lo
que el programa no finaliza, hasta
que el usuario pulse enter.

Ejemplo

#include <iostream>
int main(void)
{
std::cout << "Hola Mundo" << std::endl;
std::cin.get();
 //con 'std::cin.get();' lo que se hace es esperar hasta que el
usuario pulse enter.
return 0;
}

Los pasos siguientes son para una

compilación en GNU o sistema
operativo Unix. En Windows tampoco
es aplicable.

Con ctrl-x ctrl-s se guarda el archivo.

Ahora para generar el ejecutable del
programa se compila con g++ de la
siguiente forma:

$ g++ hola.cpp -o hola

Para poder ver los resultados del
programa en acción, se ejecuta el
programa de la siguiente forma:

$./hola

Y a continuación se debe mostrar

algo como lo siguiente:

Hola Mundo

Comentarios

Cuando se escriben programas es

muy útil agregar comentarios que
ayuden a explicar lo que realiza un
programa. En C++ se pueden utilizar
tres tipos de comentarios: al estilo C,
al estilo C++ y usando preprocesador.

Los comentarios al estilo C se

caracterizan por lo siguiente:
comenzar el "bloque" de comentarios
con /* y terminar dicho "bloque" de
comentarios con */

Ej:

/*

Este es un comentario al estilo C.

Todo lo escrito dentro de las etiquetas de apertura y cierre es un
comentario.
A estos comentarios se le llaman multilínea, lógicamente
por el hecho de permitir varias líneas de comentarios.

*/
Si se usan este tipo de etiquetas de
comentarios, hay que tener cuidado
con el cierre (*/), por que el
compilador puede tomar todo el texto
como comentario, o cerrar antes de
lo deseado.

Usando el estilo de código de C++

sólo pueden ocupar una línea como
en el siguiente código:

// Este es un comentario al estilo C++

Una buena práctica de programación

es pensar que se programa a
sabiendas de que otro programador,
tal vez el lector mismo en un futuro,
tenga que "desencriptar" qué quiso
hacer ahí y por qué.

Otra posible forma de comentar

código es usando el preprocesador.
Esto se detalla más adelante en
profundidad, por ahora la parte útil
del preprocesador que interesa es la
siguiente:

#if 0
Comentarios sobre el programa /parte del programa.
Pueden ocupar múltiples líneas.

Más complicado de visualizar que los comentarios C/C++

#endif

Este tipo de comentarios se usan rara

vez. Generalmente son difíciles de
localizar, incluso para programadores
experimentados que trabajan en
papel, y son fáciles de distinguir en
casi cualquier IDE. Es recomendable
indicar que se tratan de comentarios,
o directamente no usarlos, salvo si
son grandes cantidades de
comentarios. Se verá más adelante
que también puede tener otros usos.

Utilización de la consola o
terminal

En los ejemplos anteriores se

utilizaron 'std::cout'. 'std::cout' es un
"objeto" que permite escribir en la
consola (la terminal en
GNU/Unix/MacOSX), solo se puede
utilizar gracias a que se ha incluido
definiciones de su uso con la línea de
código '#include <iostream>'.

std::cout << ALGO;

Donde ALGO puede ser lo que sea

que 'std::cout' sea capaz de mostrar
por consola. Más adelante se trata
más sobre ello en detalle y aclarando
posibles dudas que ahora puedan
surgir. También se utilizó 'std::endl',
esto permite que el texto se escriba
en una nueva línea.
Un ejemplo más completo sobre la
escritura en consola es el siguiente.
Ha de tenerse en cuenta que se han
eliminado algunos comentarios
superfluos del primer programa
debido a que ahora se está tratando
con más detalle acerca del uso de
imprimir texto en la consola:
Ejemplo

// Programa que muestra diversos textos por consola

// Las librerías del sistema usadas son las siguientes

#include <iostream>

// Función: main
// Recibe: void
// Devuelve: int
// Es la función principal encargada de mostrar por consola
diferentes textos
int main(void)
{
// Ejemplo con una única línea, se muestra el uso de std::cout y
std::endl
std::cout << "Bienvenido. Soy un programa. Estoy en una linea de
codigo." << std::endl;
 // Ejemplo con una única línea de código que se puede fraccionar
mediante el uso de '<<'
std::cout << "Ahora "
<< "estoy fraccionado en el codigo, pero en la consola me
muestro como una unica frase."
<< std::endl;

// Uso de un código largo, que cuesta leer para un programador,

y que se ejecutará sin problemas.
// *** No se recomienda hacer líneas de esta manera, esta forma
de programar no es apropiada ***
std::cout << "Un gran texto puede ocupar muchas lineas."
<< std::endl
<< "Pero eso no frena al programador a que todo se pueda poner
en una unica linea de codigo y que"
<< std::endl
<< "el programa, al ejecutarse, lo situe como el programador
quiso"
<< std::endl;

return 0; // Y se termina con éxito.

}

Se reta a compilar este código y a

observar sus resultados. En este
momento el lector está capacitado
para escribir programas que
impriman por pantalla el mensaje que
se quiera.

Atención: Se hace hincapié en la

posibilidad de que las palabras
acentuadas no se puedan mostrar en
la consola. Depende completamente
del compilador que se pueda ver lo
siguiente:

std::cout << "programación";

Con algunos compiladores, verá

'programación', pero con otros puede
ver incluso 'programaci n'.
Advertencia: cout puede ser
utilizado sin tener std:: de forma
previa porque se puede introducir
una directiva, denominada 'using',
que acomoda todos los cout. De
otro modo habría un error de
compilador. Este tema se trata en
detalle más adelante.
using namespace std;

Sintaxis

Sintaxis es la forma correcta en que

se deben escribir las instrucciones
para el computador en un lenguaje de
programación específico. C++ hereda
la sintaxis de C estándar, es decir, la
mayoría de programas escritos para
el C estándar pueden ser compilados
en C++.

El punto y coma

El punto y coma es uno de los

símbolos más usados en C, C++; y se
usa con el fin de indicar el final de
una línea de instrucción. El punto y
coma es de uso obligatorio.

ejemplo
´´´´´´
clrscr(); //Limpiar
pantalla, funciona solo
con la librería conio de
Borland C++
x = a + b;

string IP = "127.0.0.1";
// Variable IP tipo
string
cout << IP << endl; //
Devuelve 127.0.0.1

char Saludo[5] = "Hola";

// Variable Saludo tipo
char
 cout << Saludo[0] <<
endl; // Igual a H
cout << Saludo[1] <<
endl; // Igual a o
cout << Saludo[2] <<
endl; // Igual a l
cout << Saludo[3] <<
endl; // Igual a a

El punto y coma se usa también para

separar contadores, condicionales e
incrementadores dentro de una
sentencia for

ejemplo
 for (i=0; i < 10; i++)
cout << i;

Espacios y tabuladores

Usar caracteres extras de espaciado

o tabuladores ( caracteres tab ) es un
mecanismo que nos permite ordenar
de manera más clara el código del
programa que estemos escribiendo,
sin embargo, el uso de estos es
opcional ya que el compilador ignora
la presencia de los mismos. Por
ejemplo, el segundo de los ejemplos
anteriores se podría escribir como:

for (int i=0; i < 10;

i++) { cout << i * x;
x++; }

y el compilador no pondría ningún

reparo.

Tipos primitivos

En un lenguaje de programación es
indispensable poder almacenar
información, para esto en C++ están
disponibles los siguientes tipos que
permiten almacenar información
numérica de tipo entero o real:

Nombre Descripción Tamaño* Rango de valores*

con signo: -128 to 127

char Carácter o entero pequeño 1byte
sin signo: 0 a 255

con signo: -32768 a

short int 32767
Entero corto 2bytes
(short)
sin signo: 0 a 65535

con signo: -2147483648

a 2147483647
int Entero 4bytes
sin signo: 0 a
4294967295

con signo: -2147483648

a 2147483647
long int
Entero largo 8bytes
(long) sin signo: 0 a
4294967295

Valor booleano. Puede tomar dos

bool 1byte true o false
valores: verdadero o falso

float Número de punto flotante 4bytes 3.4e +/- 38 (7 digitos)

De punto flotante de doble

double 8bytes 1.7e +/- 308 (15 digitos)
precisión

long Long de punto flotante de doble

8bytes 1.7e +/- 308 (15 digitos)
double precisión
 Los valores dependen de la
arquitectura utilizada. Los
mostrados son los que
generalmente se encuentran en
una máquina típica de arquitectura
32 bits.

El modificador long

El modificador long le indica al

compilador que el tipo debe utilizar
más bits que los normalmente
utilizados por ejemplo si tenemos en
una máquina de 32 bits como un
Pentium de Intel, normalmente de un
int ocupa 32 bits, pero si al declarar
un entero le anteceden long, este
entero ocupa 64 bits, el siguiente
código muestra como utilizar este
modificador:

int corto; //
Entero de 32 bits
long int largo; //
Entero de 64 bits

El Modificador short

Similar al anterior, pero indica que se

deben utilizar menos bits. Por
ejemplo, en un computador de 32
bits, un short int ocupa 16 bits.

El Modificador unsigned

El modificador unsigned es utilizado

únicamente con los enteros, permite
utilizar todo el rango posible de
valores en positivo,

int a; //
Almacena valores entre
-32768 y 32767
unsigned int a; //
 Almacena valores entre 0
y 65535

El Modificador register

Este modificador sobre una variable

le indica al compilador que la variable
debe almacenarse en un registro en
el compilador, que para el caso de los
IA32, es un registro real de la propia
CPU, y por tanto el tiempo de acceso
es más rápido respecto a la memoria
RAM. Hoy en día apenas se utiliza
este modificador, ya que los
compiladores son capaces de
determinar de manera óptima la
asignación de registros a variables
del programa.

El Modificador volatile

Al contrario que el modificador

registrer, volatile obliga al compilador
a forzar el código resultante de
manera que la variable modificada
con este modificador, sea
almacenada siempre en la memoria.
El efecto que tiene es que cuando la
variable se modifica con otro valor,
dicha variable se almacena
directamente en memoria y no queda
localizado el valor sólo en el registro
de la CPU como pasaba en el caso de
register o en condiciones normales.
Un uso muy común en el que se suele
emplear este modificador, es para
acceder a variables que están siendo
utilizadas por drivers o por
periféricos, ya que si no
declarásemos esta propiedad, podría
darse el caso que la CPU usase el
valor de la variable, por lo que la
caché guarda el valor, y poco
después la CPU usase de nuevo
dicha variable, pero como ésta está
en cache, la CPU coge el valor que
existe en la caché, que puede ser bien
distinta al real puesto que un posible
periférico puede haber modificado su
valor.

El Modificador static

Dependiendo del entorno donde se

declare la variable que la
modifiquemos como static, puede
significar dos cosas muy distintas:

1. Si declaramos una variable

static dentro del cuerpo de una
función, lo que estamos
indicándole al compilador es
que dicha variable sea
inicializada solo una vez (la
primera vez que se llama a la
 función), y el resto de veces que
se llame a la función, la variable
contendrá el último valor
asignado. Esta variable sólo
podrá ser visible desde la
función que declara dicha
variable. Por ejemplo:

void mifuncion(){
static int i=0;
cout<<"En la entrada i
vale "<<i<<endl;
for(int j=0;j<10;j++)
i++;
cout<<"En la salida i
vale "<<i<<endl;
}

1. Si declaramos una variable

static fuera del cuerpo de una
función, lo que le estamos
indicando al compilador, es que
dicha variable es privada para el
modulo donde se implementa el
código del contexto de la
variable, es decir, que otro
fichero objeto binario, no podrá
tener acceso a dicha variable
utilizando el modificador extern.
Ejemplo:
#import "prueba.h"

//variable privada para

prueba.cpp
static int i=0;

void mifuncion(){
cout<<"En la entrada i
vale "<<i<<endl;
for(int j=0;j<10;j++)
i++;
cout<<"En la salida i
vale "<<i<<endl;
}
Tenga en cuenta que para este último
caso, usted podrá acceder a la
variable y desde cualquier función
que defina dentro de prueba.cpp,
pero no tendrá acceso desde
cualquier fichero objeto o fuente que
no sea prueba.cpp

Espacio que ocupan la variables

(en máquinas x86)

El espacio en bits que ocupan en la

computadora una variable de este
tipo se puede ver en la siguiente
tabla: