1.

-IDENTIFICADORES

Los identificadores (nombres de variables, constantes, etc.) deben comenzar con una letra del
alfabeto (mayscula o minscula) o con un carcter subrayado y pueden tener uno o ms
caracteres. Los caracteres segundos y posteriores pueden ser letras, dgitos o un subrayado, no
permitindose caracteres no alfanumricos ni espacios.
C++ es sensible a las maysculas. Las letras maysculas y minsculas se consideran diferentes.
Paga_mes es un identificador distinto a paga_mes

Palabras reservadas

Las palabras reservadas o claves no se pueden utilizar como identificadores, debido a su
significado estricto en C++; tampoco se pueden redefinir. La Tabla enumera las palabras
reservadas de C++ segn el ARM2.
Tabla Palabras reservadas (keywords) de ANSI/ISO C++
asm*
default
for
new*
sizeof
typedef
auto
delete*
friend*
operator*
static
typename
bool*
do
goto
private*
struct
union
break
double
if
protected*
switch
unsigned
case
else
inline*
public*
template*
using
catch*
enum
int
register
this*
virtual*
char
explicit*
long
return
throw*
void
class*
extern
mutable*
short
true*
volatile*
const
false*
namespace*
signed
try*
while
continue
float
* Estas palabras no existen en C ANSI.
Los diferentes compiladores comerciales de C++ pueden incluir, adems, nuevas palabras
reservadas. Estos son los casos de Borland, Microsoft y Symantec.
Nuevas palabras reservadas de ANSI C++
bool
false
reinterpret_cast
typeid
cons_cast
mutable
static_cast
using
dynamic_cast
namespace
true
wchar_t
Identificadores de constantes predefinidas

Constantes
C++ contiene constantes para cada tipo de dato simple (integer, char, etctera). Las constantes
pueden tener tres sufijos, u, l y f, que indican tipos unsigned, long y float, respectivamente.
Asimismo, se pueden aadir los prefijos o y ox que representan constantes octales y
hexadecimales.
456 0456 Ox456 //constantes enteras: decimal, octal, hexadecimal
1231 123ul //constantes enteras: long, unsigned long
'B' 'b' '4' //constantes tipo char
3.1415f 3.14159L //constantes reales de diferente posicin
cadena de caracteres //constante de cadena
Las cadenas de caracteres se encierran entre comillas, y las constantes de un solo carcter se
encierran entre comillas simples.
//cadena vaca, '\0'
Una constante literal es un valor escrito directamente en el programa siempre que se necesite. Por
ejemplo,
int miEdad = 25;
miEdad es una variable de tipo int; 25 es una constante literal.
Constantes con const
En C++, los identificadores de variables/constantes se pueden declarar constantes, significando
que su valor se inicializa pero no se puede modificar.
Estas constantes se denominan simblicas. Esta declaracin se realiza con la palabra reservada
const.
const double PI = 3.1416;
const char BLANCO = ' ';
const double PI_EG = PI;
const double DOBLE_PI = 2*PI;
El modificador de tipos const se utiliza en C++ tambin para proporcionar proteccin de slo
lectura para variables y parmetros de funciones.

Las funciones miembro de una clase que no modifican los miembros dato a que acceden pueden
ser declarados const. Este modificador evita tambin que parmetros parados por referencia sean
modificados:
void copy (const char* fuente, char* destino);
Constantes con define#
C++ soporta tambin el mtodo tradicional de declaracin de constantes, aunque ahora est
obsoleto. Para declarar una constante por este mtodo se debe realizar con la palabra reservada
#define.
#define estudiantesPorClave 50
#define PI 3.1416
#define hex 16
Nomenclatura de constantes
* Los nombres de constantes tienen que ser auto explicativos.
En s mismos tienen que contener una explicacin de su uso o finalidad.
* Para componer los nombres de constantes se utilizarn principalmente sustantivos, pudiendo
calificarse con adjetivos.
Esto se realizar as para mejorar la identificacin de los distintos componentes de un sistema.
* Las constantes se tienen que definir en maysculas (tanto las definidas por #define como las
definidas utilizando const).
Si se componen de varias palabras se deberan separan por el carcter "_".
La constante se conformar mediante un sustantivo (o conjunto de sustantivos) con posibles
adjetivos.
De esta forma seguimos una norma ampliamente utilizada por los programadores.
Ejemplos de definicin de constantes:
#define PI 3.14
#define DIAS_DE_LA_SEMANA 7

Utilizacin de defines, macros, constantes
* Se deben utilizar constantes (const) o enumeraciones (enum) para definir constantes, evitando
el uso de constantes con #define en lo posible.
#define es una directiva para el preprocesador, la cual se aplica con carcter global antes de hacer
ninguna comprobacin por parte del compilador. Sus problemas son los consabidos efectos
colaterales.
Por ejemplo sera desaconsejable utilizar lo siguiente:
// Definimos (desaconsejado) valores para datos y constantes
// con #define
typedef int BOOLE // el tipo de dato para los resultados
#define FALSO 0 // definicin de resultado falso
#define CIERTO 1 // definicin de resultado cierto
// El numero de das de una semana
#define DIAS_DE_LA_SEMANA 7
Sera ms correcto utilizar lo siguiente:
enum EBoole // Definimos el tipo de dato EBoole para los resultados
{
FALSO, // 0 por defecto
CIERTO // Verdad = 1
};
// La constante numero de das de la semana
const int nDIAS_SEMANA = 7;

Identificadores de tipos de datos, funciones y procedimientos predefinidos
Tipos de datos
Los tipos de datos en C++ se dividen en dos grandes grupos: integrales (datos enteros) y de coma
flotante (datos reales). La Tabla muestra los diferentes tipos de datos en C++
Tipos de datos simples en c++
char
signed char
unsigned char
short
int
long
unsigned short
unsigned
unsigned long
float
double
long doubl

Los tipos derivados en C++ pueden ser:
Enumeraciones (enum)
Estructuras (struc)
Uniones (union)
Arrays
Clases (class y struct)
Uniones y enumeraciones annimas
Punteros
Identificadores de constantes definidas por el usuario
Identificadores de tipos definidos por el usuario
Identificadores de variables y parmetros

Declaracin de variables
Todas las declaraciones de variables y funciones se deben hacer al principio del programa o
funcin. Si se necesitan declaraciones adicionales, el programador debe volver al bloque de
declaraciones al objeto de hacer los ajustes o inserciones necesarios. Todas las declaraciones
deben hacerse antes de que se ejecute cualquier sentencia. As, la declaracin tpica en C++
En C++, las declaraciones de variables se pueden situar en cualquier parte de un programa. Esta
caracterstica hace que el programador declare sus variables en la proximidad del lugar donde se
utilizan las sentencias de su programa.
Nomenclatura de las variables
* Los nombres utilizados para las variables tienen que ser autoexplicativos. De manera que en el
propio nombre est la indicacin del uso o finalidad de las variables.
* Para componer los nombres de las variables se utilizarn principalmente sustantivos, pudiendo
calificarse con adjetivos.
Esta norma se establece para mejorar la identificacin de los distintos componentes de un
sistema.
* Una prctica muy habitual es utilizar una serie de prefijos para poder identificar el tipo de
variable de una forma sencilla y rpida. Este tipo de nomenclaturas se denomina notacin
hngara.
Estos prefijos se aaden al nombre de la variable, sin separarlos de ninguna forma, como se
muestra en los ejemplos de la tabla.
Tipo Prefijo Ejemplo
void v void vVariableVaca;
bool b bool bOperacionValida;
char c char cTeclaPulsada;
int n int nNumeroCeldas;
long l long lTotalUnidades;
float f float fPrecioUnitario;
double d double dAnguloMinimo;
* (puntero) p int * pnMatrizValores;
& (referencia (C++)) r float & rfMaximoAngulo;
[] (array) a double afRangosMaximos[3];
enum (enumeracin) e EBoole eResultado;

Como se ve en los mismos ejemplos indicados en esta tabla, se pueden utilizar varios de estos
prefijos en una misma definicin.
Para el tema de cadenas de caracteres (strings, no confundir con la clase String), podramos pensar
que la forma correcta de definirlas es, por ejemplo: char acNombrefichero[256+1];. Pero para
poder identificarlas, ya que se usan de manera extendida, podramos usar el prefijo s. Por ejemplo:
// definicin de una cadena de caracteres
char sNombreFichero [256+1];
De forma adicional, podramos diferenciar la definicin de una cadena de caracteres mediante el
uso de [] (corchetes) (como en el ejemplo anterior) de la definicin de un puntero a carcter (char
*) que contendra la direccin de memoria donde empieza esta cadena de caracteres.
// definicin de un puntero a una zona de memoria que contiene una cadena
char *psPunteroAlNombre;
Estas dos definiciones se usan para esos casos, y quizs contradigan en parte la anterior norma de
nomenclatura, pero pueden ayudar a diferenciar las variables "cadena de caracteres" definidas por
[] (corchetes) de las definidas mediante char * (puntero a carcter), ya que pueden ser tratadas de
manera muy diferente por los compiladores, y la forma de utilizarlas por el programador es
diferente.
Para otros tipos de variable no especificados en la tabla anterior no se establece prefijo, pero se
puede utilizar algn otro definido por otra norma o por el propio usuario.
Por ejemplo los siguientes:
Tipo Prefijo
byte o unsigned char (uchar) by
word o unsigned int (uint) w
unsigned long (dword) dw
handle (manejador, puntero de objetos de windows) h

* Para el contador de bucle for se pueden utilizar variables numricas llamada i, j... siempre que
esto no perjudique en la comprensin del cdigo (y estas variables se utilicen solamente dentro
del bucle del for).
Para estos casos (C++) se recomienda declarar la variable i en el propio bucle.
Ejemplo:
for (int i=0; i<strlen(sCadenaPrueba); i++) { ... }

Utilizacin de variables
* Todas las variables hay que declararlas en el mbito ms restringido posible.
Esto lleva a una utilizacin ms eficiente de la pila y a una reduccin de los posibles errores por
efectos "colaterales".
* En general se aconseja limitar al mximo posible la visibilidad de las variables.
Como norma general de proteccin de datos.
* Se debe evitar la conversin explcita de tipos de datos, ya que atenta contra la comprobacin de
tipos de datos que hace el compilador.
Se aconseja utilizar la conversin implcita de tipos de datos cuando sea posible.
* Se aconseja que cada variable se declare de forma separada.
As se desaconseja una definicin como la siguiente:
// Multiple definicin de variables, desaconsejada
int nContador, nNumeroFilas, nNumeroColumnas, nTotalElementos;
Mientras que lo correcto sera lo siguiente:
// Definicin correcta de variables.
int nContador;
int nNumeroFilas;
int nNumeroColumnas;
int nTotalElementos;
* Usar unsigned para variables que se sepa con seguridad que nunca van a tomar valores
negativos.
* Es aconsejable que todas las variables sean inicializadas en la propia declaracin de las mismas.
Por ejemplo:
// Definicin ms correcta de variables, con inicializacin.
int nContador = 0;
int nNumeroFilas = 0;
int nNumeroColumnas = 0;
int nTotalElementos = 0;

Identificadores de funciones

Una funcin es una coleccin de declaraciones y sentencias que realizan una tarea nica. Cada
funcin tiene cuatro componentes:
1) su nombre;
2) el tipo de valor que devuelve cuando termina su tarea;
3) la informacin que toma al realizar su tarea,
4) la sentencia o sentencias que realizan su tarea. Cada programa C++ tiene al menos una funcin:
la funcin main.
Declaracin de funciones
En C + + se debe declarar una funcin antes de utilizarla. La declaracin de la funcin indica al
compilador el tipo de valor que devuelve la funcin y el nmero y tipo de argumentos que toma.
La declaracin en C++ se denomina prototipo:
tipoNombreFuncion (lista argumentos);
Ejemplos vlidos son:
double Media(double x, double y);
void Print(char* formato, ...);
extern max(const int*, int);
char LeerCaracter();
Nomenclatura de las funciones
* Los nombres de las funciones tienen que ser auto explicativos. Tienen que dar una idea clara de
cul es su finalidad.
* Los nombres de las funciones deberan empezar por una letra minscula (por el contrario los
mtodos de las clases tienen que empezar por una letra mayscula).
As seguimos una nomenclatura ampliamente difundida y utilizada.
De manera que sera poco correcto llamar a una funcin:
// Definicin poco correcta de una funcin
int RealizarCopia (char *psDestino, char *psOrigen);
Mientras que sera correcto llamarla:
// Definicin correcta de una funcin
int realizarCopia (char *psDestino, char *psOrigen);
* Para componer los nombres de las funciones se aconseja utilizar formas verbales (infinitivos)
pudindose acompaar (o no) con sustantivos para precisar la accin.
De esta manera mejoramos la identificacin de los distintos componentes de un sistema.
Por ejemplo, una funcin que hace una carga de datos en un array si la llamamos datos() no queda
clara su finalidad, en cambio si la llamamos cargarDatosIniciales() est muy claro su uso.
Utilizacin de funciones
* En general se aconseja limitar el mximo posible la visibilidad de las funciones.
Como norma general de proteccin de datos.








2.-Estructura del programa
2.1 Utilizacin de elementos LOCALES y GLOBALES

Variables locales
* Las variables locales se deberan definir solamente en el bloque en el que se vayan a utilizar (en
C++).
As mejoraramos el uso de la pila.
* Las variables locales se deberan definir justo antes de su utilizacin (en C++).
De esta manera se evita el error habitual de tener variables definidas que luego no se utilizan.
Variables globales
* En general: NO UTILIZAR VARIABLES GLOBALES salvo en caso totalmente inevitable.
La existencia de variables globales atenta contra la comprensin del cdigo y su encapsulamiento,
adems de que puede provocar efectos "colaterales" inesperados (si una funcin vara el valor de
la variable global de forma no controlada) que desembocan en errores muy difciles de identificar.
* En el caso completamente inevitable de tener que utilizar variables globales, documentar
ampliamente en los ficheros y funciones que variables globales se van a utilizar, y cuales se van a
modificar.
Variables estticas
* Se recomienda minimizar el uso de variables estticas, y solamente para casos en los que se
necesite "recordar" el estado de una funcin entre llamadas consecutivas a la misma.
No se deberan utilizar las variables estticas como variables globales ocultas.
* Las variables estticas se tienen que inicializar en el momento en que se declaran, de manera
obligatoria.
3.6 Inicializacin de variables
* Todas las variables hay que inicializarlas explcitamente antes de ser utilizadas, en especial las
que se alojan en la pila y las que obtienen espacio de almacenamiento de forma dinmica durante
la ejecucin.
De esta manera evitamos la ejecucin de cdigo con valores desconocidos de las variables, que
provoca el funcionamiento aleatorio del programa.
* Las variables estticas se tienen que inicializar en el momento en que se declaran.


2.2 Estructura general de las partes del programa
// El comentario general del propsito del programa debe de ir aqu

SECCI N DEL PREPROCESADOR

#include <iostream.h>
#include <nombreArchivo>
Lugar para declaraciones de las constantes globales
SECCI N FUNCI N PRI NCI PAL

void main( void )
{ // Empieza el bloque de la funcin principal
Las definiciones variable y constante locales para main( ) van aqu
La seccin de enunciados del programa va aqu
} // Final del bloque de la funcin principal
Ejemplo:


2.3 Estructura de las sentencias

Un programa en C++ consta de una secuencia de sentencias. Existen diversos tipos de sentencias.
El punto y coma se utiliza como elemento terminal de cada sentencia
-Sentencias de declaracin
Se utilizan para establecer la existencia y, opcionalmente, los valores iniciales de objetos
identificados por nombre.
NombreTipo identificador, ...;
NombreTipo identificador = expresin, ...;
const NombreTipo identificador = expresin, ...;
Algunas sentencias vlidas en C++ son:
char c1;
int p, q = 5, r = a+b; //suponiendo que a y b han sido
//declaradas e inicializadas antes
const double IVA = 16.0;
-Sentencias de expresin
Las sentencias de expresiones hacen que la expresin sea evaluada. Su formato general es:
expresin;
ejemplos
n++;
425; //legal, pero no hace nada
a+b; //legal, pero no hace nada
n = a < b || b != 0;
a += b = 3; //sentencia compleja
m = n +(p = 5); equivale a p = 5
m = n + p;
Sentencia compuesta

Una sentencia compuesta es una serie de sentencias encerradas entre llaves.
Las sentencias compuestas tienen el formato:
{
sentencia
sentencia
sentencia
...
}
Las sentencias encerradas pueden ser cualquiera: declaraciones, expresiones, sentencias
compuestas, etc. Un ejemplo es:
{
int i = 5;
double x = 3.14, y = -4.25;
int j = 4-i;
x = 4.5*(x-y);
}
El cuerpo de una funcin C++ es siempre una sentencia compuesta
Sentencia condicional simple (IF)

El formato general de una sentencia if es:

if (expresin) if (expresin) {
sentencia <secuencia de sentencias>
}

Si expresin es verdadera (distinta de cero), entonces se ejecuta sentencia o secuencia de
sentencias; en caso contrario se salta la sentencia.
Despus que la sentencia if se ha ejecutado, el control pasa a la siguiente sentencia.
Sentencia condicional compuesta (IF ELSE)

Si expresin es distinto de cero, la sentencia1 se ejecuta y sentencia2 se salta; si expresin es cero,
la sentencia1 se salta y sentencia2 se ejecuta. Una vez que se ha ejecutado la sentencia if_else, el
control pasa a la siguiente sentencia
if (expresion)
sentencia;
else
sentencia;






if (expresion){
<secuencia de sentencias>
}
else {
<secuencia de sentencias>
}


Sentencia condicional mltiple (IF ELSE IF)

C++ permite anidar sentencias if_else para crear una sentencia de alternativa mltiple:
if (expresin 1)
sentencia 1; | {sentenca compuesta}
else if (expresin 2)
sentencia 2; | {sentencia compuesta}
else if (expresion N)
sentencia N; | {sentencia compuesta}
[else
sentencia N+1; | {sentenca compuesta}]


Sentencia condicional mltiple (switch)

La sentencia switch ofrece una forma de realizar decisiones de alternativas mltiples. El formato
de switch es:
switch(expresion)
{
case constante 1:
sentencias
break;
case constante 2:
sentencias
.
.
.
break;
case constante n:
sentencias
break;
default: //opcional
sentencias
}
La sentencia switch requiere una expresin cuyo valor sea entero.
Este valor puede ser una constante, una variable, una llamada a funcin o una expresin. El valor
de constante ha de ser una constante. Al ejecutar la sentencia se evala expresin, y si su valor
coincide con una constante, se ejecutan las sentencias a continuacin de ella; en caso contrario se
ejecutan las sentencias a continuacin de default.
switch (Puntos)
{
case 10:
nota ='A';
break;
case 9:
nota = 'B';
break;
case 7,8:
nota = 'C';
break;
case 5,6:
nota = 'D';
break;
default:
nota = 'F';
}

Bucles: Sentencias repetitivas

Los bucles sirven para realizar tareas repetitivas. En C++ existen tres diferentes tipos de sentencias
repetitivas:
while.
do.
for.
Sentencia repetitiva con condicin de entrada (WHILE)
La sentencia while es un bucle condicional que se repite mientras la condicin es verdadera. El
bucle while nunca puede iterar si la condicin comprobada es inicialmente falsa. La sintaxis de la
sentencia while es:
while (expresin)
sentencia;
o bien,
while (expresin){
< secuencia de sentencias >
}
Sentencia repetitiva con condicin de salida (do)

La sentencia do acta como la sentencia while. La nica diferencia real es que la evaluacin y la
prueba de salida del bucle se hace despus que el cuerpo del bucle se ha ejecutado, en lugar de
antes. El formato es:
do
sentencia
while (expresion);
sentencia siguiente
Se ejecuta sentencia y a continuacin se evala expresin, y si es verdadero (distinto de cero), el
control se pasa de nuevo al principio de la sentencia do, y el proceso se repite hasta que expresin
es falso (cero) y el control pasa a la sentencia siguiente.
Sentencia repetitiva con nmero predeterminado de iteraciones (FOR)

Una sentencia for ejecuta la iteracin de un bucle un nmero determinado de veces. for tiene tres
componentes: expresin1 inicializa las variables de control del bucle; expresin2 es la condicin
que determina si el bucle realiza otra iteracin; la ltima parte del bucle for es la clusula que
incrementa o decrementa las variables de control del bucle. El formato general de for es:
for (expresin1; expresin2; expresin3)
sentencia;|{<secuencia de sentencias>};

expresin1 se utiliza para inicializar la variable de control de bucle; a continuacin, expresin2 se
evala; si es verdadera (distinta de cero), se ejecuta la sentencia y se evala expresin3, y el
control pasa de nuevo al principio del bucle. La iteracin contina hasta que expresin2 es falsa
(cero), en cuyo momento el control pasa a la sentencia siguiente al bucle
Sentencia Break y continue

El flujo de control ordinario de un bucle se puede romper o interrumpir mediante las sentencias
break y continue.
La sentencia break produce una salida inmediata del bucle for en que se encuentra situada:
for (i = 0; i < 100; ++i)
{
cin >> x;
if (x < 0.0)
cout << salir del bucle << endl;
break;
}
cout << sqrt (x) << endl;
}
La sentencia break tambin se utiliza para salir de la sentencia switch.
La sentencia continue termina la iteracin que se est realizando y comenzar de nuevo la
siguiente iteracin:
for (i = 0; i < 100; ++i)
cin >> x;
if (x < 0.0)
continue;
Sentencia nula
La sentencia nula se representa por un punto y coma, y no hace ninguna accin.
char cad*80+=Cazorla;
int i;
for(i=0; cad[i] !='\0'; i++)
;
Sentencia return
La sentencia return detiene la ejecucin de la funcin actual y devuelve el control a la funcin
llamada. Su sintaxis es:
return expresion;
donde el valor de expresin se devuelve como el valor de la funcin

2.4 Comentarios y lneas en blanco

* Los comentarios deben ser minimizados (utilizar comentarios muy largos puede entorpecer la
lectura), deben facilitar la comprensin del cdigo y aportar informacin til sobre las sentencias,
bloques, variables, funciones, etc... que afectan.
En ningn momento hay que poner demasiados comentarios (comentar todas las instrucciones
utilizadas, por ejemplo, no aporta nada y entorpecen la lectura) que puedan dificultar la
comprensin del programa o que no aporten ninguna informacin til sobre el mismo.
* Es aconsejable comentar los ficheros, funciones y bloques de cdigo, para as ofrecer
informacin til sobre su funcionalidad o su uso, pero sin extenderse de forma innecesaria.
En otros apartados se comenta esto mismo, indicando la estructura de estos comentarios
explicativos.
* Se recomienda comentar las declaraciones de datos no auto explicativas, y la omisin
intencionada de cdigo.
* Hay mantener y actualizar los comentarios a la vez que se mantiene y actualiza el cdigo.
Unos comentarios no actualizados pueden llevar a error al revisar el fuente.
* En C los comentarios solamente se construyen con /* ...... */.
/* Estilo de comentario en C */
/* Comentario que se escribiria en C
* dividido en varias lineas. */
En C hay que tener mucho cuidado al utilizar los comentarios que abarquen varias lneas.
Algunos editores marcan con /* la primera linea del comentario y con * las siguientes, la ltima
terminara en */ (como en el ejemplo mostrado).
* En C++ los comentarios tendran que ser solamente los construidos con //.
// Estilo de comentario en C++
// Comentario que se escribiria en C++
// dividido en varias lineas.
* En caso de trabajar en C++ se aconseja utilizar solamente los comentarios propios del C++. Los
comentarios de C pueden llevar a errores ocultos en caso de tener comentarios anidados (que en
unos compiladores produciran errores, y en otros no).
El siguiente ejemplo de comentario puede no compilar en algunos compiladores
/* Una primera linea de error
/* Un comentario anidado */
El comentario anidado puede provocar que no se compile.
en determinados compiladores */
Notacin Hngara simplificada
1.-Prefijos para tipos simples
2.-Prefijos para tipos compuestos
3.-Prefijos para punteros
4.-Prefijo para identificadores de funciones
5.- Prefijos para identificadores de tipos