Guía de Sintaxis Ansi/Iso Estándar C++: Apéndiceb

APNDICE B
GUA DE SINTAXIS ANSI/ISO

ESTNDAR C++
CONTENIDO
B.1. Elementos del lenguaje. B.12. Los operadores new y delete.

B.2. Tipos de datos. B.13. Array.
B.3. Constantes. B.14. Enumeraciones, estructuras y uniones.
B.4. Conversin de tipos. B.15. Cadenas.
B.5. Declaracin de variables. B.16. Funciones.
B.6. Operadores. B.17. Clases.
B.7. Entradas y salidas bsicas. B.18. Herencia.
B.8. Sentencias. B.19. Sobrecarga de operadores.
B.9. Sentencias condicionales: if. B.20. Plantillas (templates).
B.10. Bucles: sentencias repetitivas. B.21. Excepciones.
B.11. Punteros (apuntadores). B.22. Espacio de nombres (Namespaces).
C++ es considerado un C ms grande y potente. La sintaxis de C++ es una a b c d e f g h i j k l m n o p q r s t u v w x y z

extensin de C, al que se han aadido numerosas propiedades, fundamen- A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
talmente orientadas a objetos. C ANSI 1 ya adopt numerosas caractersticas 0 1 2 3 4 5 6 7 8 9
+ - * / = ( ) { } [ ] < > ! @ /
= $ ^ & % - : . , ; ? \ |
de C++, por lo que la emigracin de C a C++ no suele ser difcil.
En este apndice se muestran las reglas de sintaxis del estndar clsico de caracteres espacio (blancos y tabulaciones).
C++ recogidas en al Annotated Reference Manual (ARM), de Stroustrup &
Ellis, as como las ltimas propuestas incorporadas al nuevo borrador de C++
ANSI, que se incluyen en las versiones 3.0 (actual) y 4.0 (futura) de AT&T C++.
B.1.2. Comentarios
C++ soporta dos tipos de comentarios. Las lneas de comentarios al estilo C
y C ANSI, tal como:
B.1. ELEMENTOS DEL LENGUAJE
/* Comentario estilo C*/, se puede extender
Un programa en C++ es una secuencia de caracteres que se agrupan en /* hasta que aparece la marca de cierre */
componentes lxicos (tokens) que comprenden el vocabulario bsico del // Este tipo de comentario termina al final de la lnea
lenguaje. Estos componentes de lxico son: palabras reservadas, identifica- // Slo es posible una lnea de comentario
dores, constantes, constantes de cadena, operadores y signos de puntuacin.
La versin /*...*/ se utiliza para comentarios que excedan una lnea
de longitud, y la versin //... se utiliza slo para comentarios de una lnea.
B.1.1. Caracteres Los comentarios no se anidan.
Los caracteres que se pueden utilizar para construir elementos del lenguaje
(componentes lxicos o tokens) son: B.1.3. ldentificadores
1 Se utiliza indistintamente los trminos ANSI C (nombre ingls) y C ANSI, traduccin al Los identificadores (nombres de variables, constantes, etc.) deben comenzar
espaol muy usada en la vida profesionbal y acadmica. con una letra del alfabeto (mayscula o minscula) o con un carcter subra-
564 PROGRAMACIN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
yado y pueden tener uno o ms caracteres. Los caracteres segundo y poste- TABLA B.2. Palabras reservadas de Borland C++ 5
riores pueden ser letras, dgitos o un subrayado, no permitindose caracte- _ _asm _ _cdecl _ _cs _ _declspec _ _ds
res no alfanumricos ni espacios. _ _es _ _except _ _export _ _far _ _fastcall
test_prueba //legal _ _finally _ _huge _ _import _ _interrupt _ _loadds
X123 //legal _ _near _ _pascal _ _rtti _ _saveregs _ _seg
multi_palabra //legal _ _ss _ _stdcall _ _thread _ _try _ asm
var25 //legal _cdecl _cs _ds _es _export
15var //no legal _far _fastcall _huge _import _interrupt
_loadds _near _pascal _saveregs _seg
C++ es sensible a las maysculas. Las letras maysculas y minsculas se _ss _stdcall asm auto bool
consideran diferentes. break case catch cdecl char
class const const_cast continue default
Paga_mes es un identificador distinto a paga_mes delete do double dynamic_cast else
enum explicit extern false far
Buena prctica de programacin aconseja utilizar identificadores sig- float for friend goto huge
nificativos que ayudan a documentar un programa. if inline int interrupt long
mutable namespace near new operator
nombre apellidos salario precio_neto pascal private protected public register
Edad Longitud Altura Salario_Mes reinterpret_ cast return short signed sizeof
static static_cast struct switch template
this throw true try typedef
B.1.4. Palabras reservadas typeid typename union unsigned using
virtual void volatile wchar_ t while
Las palabras reservadas o claves no se pueden utilizar como identificadores,
debido a su significado estricto en C++; tampoco se pueden redefinir. La
Tabla B.1 enumera las palabras reservadas de C++ segn el ARM2. TABLA B.3. Palabras reservadas de Visual C++ 6
_asm _fastcall public signed
TABLA B.1. Palabras reservadas (Keywords) de ANSI/ISO C++ _except new unsigned void
_virtual_inheritance typedef using directive do
asm* default for new* sizeof typedef throw class default _leave
auto delete* friend* operator* static typename case goto _int8 struct
bool* do goto private* struct union _finally register sizeof auto
break double if protected* switch unsigned operator using declaration volatile explicit
case else inline* public* template* using typeid uuid double mutable
catch* enum int register this* virtual* const delete long true
char explicit* long return throw* void if _intl6 switch catch
class* extern mutable* short true* volatile* reinterpret_cast static template flota
const false* namespace* signed try* while return wmain _based private
continue float _uuidof dynamic-cast extern typename
dl1export man naked const-cast
* Estas palabras no existen en C ANSI. _int32 _multiple try inline
_inheritance
static-cast this _cdecl _inline
Los diferentes compiladores comerciales de C++ pueden incluir, while bool for short
adems, nuevas palabras reservadas. Estos son los casos de Borland, Micro- else false protected virtual
soft y Symantec. enum namespace union dllimport
-single-inheritance _try continue _int64
2 Siglas del libro de Margaret Ellis y Bjarne Stroustrup en el que se definen las reglas de thread char _dec1spec _stdcall
break friend int xalloc
sintaxis del lenguaje C++ estndar, Annotated Reference Manual, Addlson-Wesley, 1992.
GUA DE SINTAXIS ANSI/ISO ESTNDAR C++ 565
El comit ANSI ha aadido nuevas palabras reservadas (Tabla B.4). Fallo al devolver un valor de una funcin. Una funcin en C + +
declarada con un tipo determinado de retorno ha de devolver un valor
TABLA B.4. Nuevas palabras reservadas de ANSI C++ de ese tipo. En C est permitido no seguir la regla.
bool false reinterpret_cast typeid
Asignacin de punteros void. La asignacin de un tipo void* a un
cons_cast mutable static_cast using puntero de otro tipo se debe hacer con una conversin explcita en C
dynamic_cast namespace true wchar_t + +. En C se realiza implcitamente.
Inicializacin de constantes de cadena. En C++ se debe proporcionar un
espacio para el carcter de terminacin nulo cuando se inicializan cons-
B.2. Tipos de datos tantes de cadena. En C se permite la ausencia de ese carcter.
int main()
Los tipos de datos en C++ se dividen en dos grandes grupos: integrales {
(datos enteros) y de coma flotante (datos reales). La Tabla B.5 muestra los //...
char car[7] = Cazorla; //legal en C
diferentes tipos de datos en C++ //error en C++
//...
TABLA B.5. Tipos de datos simples en C++ return 0;
}
char signed char unsigned char
short int long Una solucin al problema que funciona tanto en C como en C++ es:
unsigned short unsigned unsigned long
char car[8] = Cazorla;
float double long double
Los tipos derivados en C++ pueden ser: B.3. CONSTANTES

enumeraciones (enum) C++ contiene constantes para cada tipo de dato simple (integer, char,
estructuras (struc) etctera). Las constantes pueden tener tres sufijos, u, l y f, que indican
uniones (union) tipos unsigned, long y float, respectivamente. Asimismo, se pueden
arrays aadir los prefijos o y ox que representan constantes octales y hexadecimales.
clases (class y struct)
uniones y enumeraciones annimas 456 0456 Ox456 //constantes enteras: decimal, octal,
punteros //hexadecimal
1231 123ul //constantes enteras: long, unsigned
//long
B.2.1. Verificacin de tipos 'B' 'b' '4' //constantes tipo char
3.1415f 3.14159L //constantes reales de diferente posicin
La verificacin o comprobacin de tipos en C++ es ms rgida (estricta) que cadena de caracteres //constante de cadena
en C.
Usar funciones declaradas. Esta accin es ilegal en C++ y est per- Las cadenas de caracteres se encierran entre comillas, y las constantes
mitida en C: de un solo carcter se encierran entre comillas simples.
int main () //cadena vaca, '\0'
{
// ... Una constante literal es un valor escrito directamente en el programa
printf (x); //C: int printf ();
//C++ es ilegal, ya que printf no est siempre que se necesite. Por ejemplo,
//permitida devuelve un int int miEdad = 25;
return 0;
} miEdad es una variable de tipo int; 25 es una constante literal.
B.3.1. Declaracin de constantes con const B.5. DECLARACIN DE VARIABLES

En C++, los identificadores de variables/constantes se pueden declarar cons- En C ANSI, todas las declaraciones de variables y funciones se deben hacer al
tantes, significando que su valor se inicializa pero no se puede modificar. principio del programa o funcin. Si se necesitan declaraciones adicionales, el
Estas constantes se denominan simblicas. Esta declaracin se realiza con la programador debe volver al bloque de declaraciones al objeto de hacer los ajus-
palabra reservada const. tes o inserciones necesarios. Todas las declaraciones deben hacerse antes de
que se ejecute cualquier sentencia. As, la declaracin tpica en C++
const double PI = 3.1416;
const char BLANCO = ' '; NombreTipo NombreVariable1, NombreVarible2, ...
const double PI_EG = PI;
const double DOBLE_PI = 2*PI; proporciona declaraciones tales como:
El modificador de tipos const se utiliza en C++ tambin para propor- int saldo, meses;
cionar proteccin de slo lectura para variables y parmetros de funciones. double clipper, salario;
Las funciones miembro de una clase que no modifican los miembros dato a
que acceden pueden ser declarados const. Este modificador evita tambin Al igual que en C, se pueden asignar valores a las variables en C++:
que parmetros parados por referencia sean modificados:
int mes = 4,dia, anyo = 1995;
void copy (const char* fuente, char* destino); double salario = 45.675;
En C++, las declaraciones de variables se pueden situar en cualquier

B.3.2. Declaracin de constantes con define# 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
C++ soporta tambin el mtodo tradicional de declaracin de constantes, programa. El siguiente programa es legal en C++ pero no es vlido en C:
aunque ahora est obsoleto. Para declarar una constante por este mtodo se
#include <iostream.h>
debe realizar con la palabra reservada #define.
int main()
#define estudiantesPorClave 50 {
#define PI 3.1416 int i;
#define hex 16 for (i=0; i < 100; ++i)
cout << i << endl;
double j;
B.4. CONVERSIN DE TIPOS for (j = 1.7547; j < 25.4675; j+= .001)
cout << i << endl;
Las conversiones explcitas se fuerzan mediante moldes (casts). La con- }
versin forzosa de tipos de C tiene el formato clsico:
(tipo) expresin
El programa anterior se podra rescribir, haciendo la declaracin y la
definicin dentro del mismo bucle:
C++ ha modificado la notacin anterior por una notacin funcional
como alternativa sintctica: int main()
{
nombre del tipo (expresin) for (int i=0; i<100; ++i)
cout << i << endl;
Las notaciones siguientes son equivalentes:
for (double j - 1.7545; j<25.4675;j += .001)
z = float(x); //notacin de moldes en C++ cout << i << endl;
z = (float)x; //notacin de moldes en C }
B.6. OPERADORES variable-

-- variable
//postdecremento
//predecremento
++a; equivale a a = a +1;
C++ es un lenguaje muy rico en operadores. Se clasifican en los siguientes --b; equivale a b = b -1;
grupos:
Aritmticos. Los formatos postfijos se conforman de modo diferente segn la
Relacionales y lgicos. expresin en que se aplica:
Asignacin. b = ++a: equivale a a = a+l; b = a;
Acceso a datos y tamao. b = a++; equivale a b = a; a = a+l;
Manipulacin de bits.
Varios. int i, j, k = 5;
k++; //k vale 6, igual efecto que ++k
Como consecuencia de la gran cantidad de operadores, se producen --k; //k vale ahora 5, igual efecto que k-
tambin una gran cantidad de expresiones diferentes. k = 5;
i = 4*k++; //k es ahora 6 e i es 20
k = 5;
B.6.1. Operadores aritmticos j = 4 * ++k; //k es ahora 6 e i es 24
C++ proporciona diferentes operadores que relacionan operaciones aritm-

ticas. B.6.2. Operadores de asignacin
TABLA B.6. Operadores aritmticos en C++ El operador de asignacin (=) hace que el valor situado a la derecha del
operador se adjudica a la variable situada a su izquierda. La asignacin
Operador Nombre Propsito Ejemplo
suele ocurrir como parte de una expresin de asignacin y las conversiones
+ Ms unitario Valor positivo de x x = + y + 5 se producen implcitamente.
- Negacin Valor negativo de x X = - y;
+ Suma Suma x e y z = x + y; z = b+5; //asigna (b+5) a variable z
- Resta Resta y de x z = x - y;
* Multiplicacin Multiplica x por y z = x * y; C++ permite asignaciones mltiples en una sola sentencia. As,
/ Divisin Divide x por y z = x/y;
% Mdulo Resto de x dividido por y z = x%y; a = b+(c=10);
++ Incremento Incrementa x despus de usar x++
-- Decremento Decrementa x antes de usar --x equivale a:
c=10;
Ejemplos a=b+c;
-i + w; //menos unitario ms unitario Otros ejemplos de expresiones vlidas y no vlidas son:

a*b/c%d //multiplicacin, divisin, mdulo
a+b a-b //suma y resta binaria //expresiones legales //expresiones no legales
a=5/2; //a toma el valor 2, si se considera a entero a=5 * (b+a); a+3 = b;
a=5/2; //a toma el valor 2.5, si a es real double x = y; PI = 3;
a=b=6; x++ = y;
Los operadores de incremento y decremento sirven para incrementar y
decrementar en uno los valores almacenados en una variable. C++ proporciona operadores de asignacin que combinan operadores
de asignacin y otros diferentes, produciendo operadores tales como +=,
variable++ //postincremento /=, =, *= y % =. C++ soporta otros tipos de operadores de asignacin
++variable //preincremento para manipulacin de bits.
TABLA B.7. Operadores aritmticos de asignacin El operador ?: se conoce como expresin condicional. La expresin
condicional es una abreviatura de la sentencia condicional if_else. La sen-
Operador Formato largo Formato corto tenca if.
+= x = x + y; x + =y;
if (condicin)
-= x = x - y; x - =y;
variable = expresinl;
*= x = x * y; x * =y;
else
/= x = x / y; x / =y; variable = expresin2;
%= x = x%y; x % =y;
es equivalente a
Ejemplos
variable =(condicin) ? expresin1 : expresin2;
a += b; equivale a a = a + b;
a *= a + b; equivale a a = a * (a+b); La expresin condicional comprueba la condicin. Si esa condicin es
v += e; equivale a v = v + e; verdadera, se asigna expresin1 a variable; en caso contrario se asigna
v -=e; equivale a v = v%e; expresin2 a variable.
Expresiones equivalentes:
Reglas prcticas
n = n+1;
n += 1; Los operadores lgicos y relacionales actan sobre valores lgicos: el valor
n++; falso puede ser o bien 0, o bien el puntero nulo, o bien 0.0; el valor verda-
++n; dero puede ser cualquier valor distinto de cero. La siguiente tabla muestra
los resultados de diferentes expresiones.
B.6.3. Operadores lgicos y relacionales x > y 1, si x excede a y, si no 0

x >= y 1, Si x es mayor que o igual a y, si no 0
Los operadores lgicos y relacionales son los bloques de construccin bsi- x < y 1, si x es menor que y, si no 0
cos para construcciones de toma de decisin en un lenguaje de programa- x <= y 1, si x es menor que o igual a y, si no 0
cin. La Tabla B.8 muestra los operadores lgicos y relacionales. x == y 1, si x es igual a y, si no 0
x! = y 1, si x e y son distintos, si no 0
TABLA B.8. Operadores lgicos y relacionales !x 1, si x es 0, si no 0
x || y 0, si ambos x e y son 0, si no 0
Operador Nombre Ejemplo
&& AND (y) lgico a && b
|| OR (o) lgico C || d Evaluacin en cortocircuito
! NOT (no) lgico !C
< Menor que i < 0 C++, igual que C, admite reducir el tiempo de las operaciones lgicas; la
<= Menor o igual que i <= 0 evaluacin de las expresiones se reduce cuando alguno de los operandos
> Mayor que j > 50 toma valores concretos.
>= Mayor o igual que j >= 8.5
1. Operacin lgica AND (&&). Si en la expresin expr1 && expr2,
== Igual a x == '\0'
expr1 toma el valor cero y la operacin lgica AND (y) siempre ser
!= No igual a c !='/n'
?: Asignacin condicional k = (i < 5)? 1= i; cero, sea cual sea el valor de expr2. En consecuencia, expr2 no se
evaluar nunca.
2. Operacin lgica OR (||). Si expr1 toma un valor distinto de cero, Ejemplos

la expresin expr1 || expr2 se evaluar a 1, cualquiera que sea el
valor de expr2; en consecuencia, expr2 no se evaluar. int m, n[12];
sizeof(m) //proporciona 4, en mquinas de 32 bits
sizeof(n) //proporciona 48
sizeof(15) //proporciona 4
B.6.4. Operadores de manipulacin de bits tamanyo = sizeof(long) - sizeof(int);
C++ proporciona operadores de manipulacin de bits, as como operadores

de asignacin de manipulacin de bits.
B.6.6. Prioridad y asociatividad de operadores
TABLA B.9. Operadores de manipulacin de bits (bitwise) Cuando se realizan expresiones en las que se mezclan operadores diferentes
es preciso establecer una precedencia (prioridad) de los operadores y la
Operador Significado Ejemplo direccin (o secuencia) de evaluacin (orden de evaluacin: izquierda-dere-
& AND bit a bit x & 128 cha, derecha-izquierda), denominada asociatividad.
| OR bit a bit j | 64 La Tabla B.11 muestra la precedencia y asociatividad de operadores.
XOR bit a bit j 12
NOT bit a bit j TABLA B.11. Precedencia y asociatividad de operadores
<< Desplazar a izquierda i << 3
>> Desplazar a derecha j >> 4 Operador Asociatividad Prioridad
::.->[]()++-- Izquierda-Derecha 1
TABLA B.10. Operadores de asignacin de manipulacin de bits ++ -- & (direccin) tipo) ! - ++ sizeof (tipo) Derecha-Izquierda 2
new delete* (indireccin)
Operador Formato largo Formato reducido
.* ->* Izquierda-Derecha 3
&= x = x & y; x & = y;
|= x = x | y; x | = y; * / % Izquierda-Derecha 4
= x = x ^ y; x = y;
<<= x = x << y; x << = y; + - Izquierda-Derecha 5
>>= x = x >> y; x >> = y;
<< >> Izquierda-Derecha 6
Ejemplos < <= > >= Izquierda-Derecha 7
x Cambia los bits 1 a 0 y los bits 0 a 1 == != Izquierda-Derecha 8

x & y Operacin lgica AND (y) bit a bit de x e y & Izquierda- Derecha 9
x | y Operacin lgica OR (o) bit a bit de x e y
Izquierda-Derecha 10
x << y x se desplaza a la izquierda (en y posiciones)
x >> y x se desplaza a la derecha (en y posiciones) | Izquierda-Derecha 11
&& Izquierda-Derecha 12
B.6.5. El operador sizeof || Izquierda-Derecha 13
El operador sizeof proporciona el tamao en bytes de un tipo de dato o ?: Derecha-Izquierda 14
variable. sizeof toma el argumento correspondiente (tipo escalar, array, re-
= += -= *= /= %= >>= <<= &= /= = Derecha-Izquierda 15
cord, etc.). La sintaxis del operador es
(operador coma) Izquierda-Derecha 16
sizeof (nombre_varable | tipo_de_dato)
Ejemplo Si se desea visualizar el valor del objeto int llamado i, se escribe la

sentencia
a * b/c +d equivale a (a*b) / (c+d)
cout << i;
B.6.7. Sobrecarga de operadores El siguiente programa visualiza en pantalla una frase:
La mayora de los operadores de C++ pueden ser sobrecargados o redefini-
int main()
dos para trabajar con nuevos tipos de datos. La Tabla B.12 lista los opera- {
dores que pueden ser sobrecargados. cout << hola, mundo\n;
}
TABLA B.12. Operadores que se pueden sobrecargar Las salidas en C++ se pueden conectar en cascada, con una facilidad de
escritura mayor que en C.
+ - * / % & |
! = < > += -= *= #include <iostream.h>
/= %= = &= |= << >> >>= int main()
<<= == != <= >= && || ++ {
-- , - >* -> () [] int i;
i = 1099;
cout << El valor de i es << i << \n;
}
Otro programa que muestra la conexin en cascada es

B.7. ENTRADAS Y SALIDAS BSICAS
Al contrario que muchos lenguajes, C++ no tiene facilidades incorporadas int main()
para manejar entrada o salida. Estas operaciones se realizan mediante rutinas {
de bibliotecas. Las clases que C + + utiliza para entrada y salida se conocen int x = 45;
como flujos. Un flujo es una secuencia de caracteres junto con una coleccin double y = 495.125;
de rutinas para insertar caracteres en flujos (a pantalla) y extraer caracteres char *c = y multiplicada por x=;
de un flujo (de teclado). cout << c << y*x << \n;
}
B.7.1. Salida
El flujo cout es el flujo de salida estndar que corresponde a stdout en
B.7.2. Entrada
C. Este flujo se deriva de la clase ostream construida en iostream.
La entrada se maneja por la clase istream. Existe un objeto predefinido is-
tream, llamado cin, que se refiere al dispositivo de entrada estndar (el
teclado). El operador que se utiliza para obtener un valor del teclado es el
operador de extraccin >>. Por ejemplo, si i era un objeto int, se escribir
Unidad cout Pantalla
central
entrada binaria salida de caracteres cin >> i;
FIGURA B.1. Uso de flujos para salida de caracteres. que obtiene un nmero del teclado y lo almacena en la variable i.
Un programa simple que lee un dato entero y lo visualiza en pantalla es: #include <iostream.h>
int main()
#include <iostream.h> {
int main() int i = 36;
{ cout << dec << i << oct << i << << hex << i << endl;
int i; }
cin >> i;
cout << i << \n;
} B.8. SENTENCIAS
Al igual que en el caso de cout, se pueden introducir datos en cascada: Un programa en C++ consta de una secuencia de sentencias. Existen diver-
sos tipos de sentencias. El punto y coma se utiliza como elemento terminal
#include <iostream.h> de cada sentencia.
int main()
{
char c[60]; B.8.1. Sentencias de declaracin
int x,y;
Se utilizan para establecer la existencia y, opcionalmente, los valores ini-
cin >> c >> x >> y; ciales de objetos identificados por nombre.
cout << c << << x << z<< y << \n;
} NombreTipo identificador, ...;
NombreTipo identificador = expresin, ...;
const NombreTipo identificador = expresin, ...;
B.7.3. Manipuladores Algunas sentencias vlidas en C++ son:
Un mtodo fcil de cambiar la anchura del flujo y otras variables de forma- char c1;
to es utilizar un operador especial denominado manipulador. Un manipula- int p, q = 5, r = a+b; //suponiendo que a y b han sido
dor acepta una referencia de flujo como un argumento y devuelve una refe- //declaradas e inicializadas antes
rencia al mismo flujo.
const double IVA = 16.0;
El siguiente programa muestra el uso de manipuladores especficamen-
te para conversiones de nmero (dec, oct, y hex):
#include <iostream.h> B.8.2. Sentencias de expresin

int main()
{ Las sentencias de expresiones hacen que la expresin sea evaluada. Su for-
int i=36; mato general es:
cout << dec << i << oct << i hex << i <<\n;
} expresin;
La salida de este programa es:
Ejemplos
36 44 24
n++;
425; //legal, pero no hace nada
Otro manipulador tpico es endl, que representa al carcter de nueva a+b; //legal, pero no hace nada
lnea (salto de lnea), y es equivalente a 'n\'. El programa anterior se n = a < b || b != 0;
puede escribir tambin as: a += b = 3; //sentencia compleja
C++ permite asignaciones mltiples en una sentencia. Ejemplo 2

m = n +(p = 5); equivale a p = 5
if (numeroDeDias < 0)
m = n + p; numeroDeDias = 0;
if ((altura - 5) < 4){

B.8.3. Sentencias compuestas area = 3.14 * radio * radio;
volumen = area * altura;
Una sentencia compuesta es una serie de sentencias encerradas entre llaves. }
Las sentencias compuestas tienen el formato:
{
sentencia Ejemplo 3
sentencia
sentencia if (temperatura >= 45)
... cout << Estoy en Sonora:Hermosillo, en agosto;
} cout << Estoy en Veracruz << temperatura << endl;
Las sentencias encerradas pueden ser cualquiera: declaraciones, expre- La frase Estoy en Sonora:Hermosillo, en agosto se visualiza
siones, sentencias compuestas, etc. Un ejemplo es: cuando temperatura es mayor o igual que 45. La sentencia siguiente se
ejecuta siempre.
{
int i = 5; La sentencia if_else tiene el formato siguiente:
double x = 3.14, y = -4.25;
int j = 4-i; 1. if (expresin) 2. if (expresin)"{
x = 4.5*(x-y); sentencia1; < secuencia de sentencias 1 >
} else else
sentencia2; < secuencia de sentencias 2 >
El cuerpo de una funcin C++ es siempre una sentencia compuesta.
Si expresin es distinto de cero, la sentencia1 se ejecuta y senten-
cia2 se salta; si expresin es cero, la sentencia1 se salta y sentencia2
B.9. SENTENCIAS CONDICIONALES: if se ejecuta. Una vez que se ha ejecutado la sentencia if_else, el control
pasa a la siguiente sentencia.
El formato general de una sentencia if es:
if (expresin) if (expresin) {
sentencia <secuencia de sentencias> Ejemplo 4
}
if (Numero == 0)
Si expresin es verdadera (distinta de cero), entonces se ejecuta sen- cout << No se calcular la media;
tencia o secuencia de sentencias; en caso contrario se salta la sentencia. else
media = total / Numero;
Despus que la sentencia if se ha ejecutado, el control pasa a la siguiente sen-
tencia.
Ejemplo 1 Ejemplo 5
if (a < 0) if (cantidad > 10){

negativos++; descuento = 0.2;
precio = n * precio(1 - descuento);
Si la variable a es negativa, se incrementa la variable negativos. }
else { break;
descuento = 0; case constante n:
precio = n * Precio; sentencias
} break;
default: //opcional
sentencias
}
B.9.1. Sentencias if _else anidadas
La sentencia switch requiere una expresin cuyo valor sea entero.
C++ permite anidar sentencias if_else para crear una sentencia de alternati- Este valor puede ser una constante, una variable, una llamada a funcin o
va mltiple: 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 cons-
if (expresin 1) tante, se ejecutan las sentencias a continuacin de ella; en caso contrario se
sentencia 1; | {sentenca compuesta} ejecutan las sentencias a continuacin de default.
else if (expresin 2)
sentencia 2; | {sentencia compuesta} switch (Puntos)
else if (expresion N) {
case 10:
sentencia N; | {sentencia compuesta}
nota ='A';
[else
break;
sentencia N+1; | {sentenca compuesta}] case 9:
nota = 'B';
break;
Ejemplo case 7,8:
nota = 'C';
if (a > 100) break;
if (b <= 0) case 5,6:
SumaP = 1; nota = 'D';
else break;
SumaN = 1; default:
else nota = 'F';
}
Numero = 1;
B.9.2. Sentencias de alternativa mltiple: switch B.10. BUCLES: SENTENCIAS REPETITIVAS
La sentencia switch ofrece una forma de realizar decisiones de alternativas Los bucles sirven para realizar tareas repetitivas. En C++ existen tres dife-
mltiples. El formato de switch es: rentes tipos de sentencias repetitivas:
while.
switch(expresion) do.
{ for.
case constante 1:
sentencias
break;
case constante 2: B.10.1. Sentencia while
sentencias
. La sentencia while es un bucle condicional que se repite mientras la con-
. dicin es verdadera. El bucle while nunca puede iterar si la condicin
. comprobada es inicialmente falsa. La sintaxis de la sentencia while es:
while (expresin) do
sentencia; {
cout <<Entrar;
o bien, cin >> n;
suma += n;
while (expresin){ i++;
< secuencia de sentencias > } while (i <=100);
} cout << La media es << double(suma)/100.0;
El siguiente ejemplo visualiza los cuadrados de 2 a 10:

Ejemplo
int i = 2;
do
int n, suma = 0;
{
int i = 1;
cout << i << por << i << = << i * i++ << endl;
}while (i < 11);
while (i <= 100)
{
cout <<Entrar;
cin >> n; B.10.3. Sentencia for
suma += n;
i++; 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
cout <<La media es << double (suma)/100.0;
realiza otra iteracin; la ltima parte del bucle for es la clusula que incre-
menta o decrementa las variables de control del bucle. El formato general
de for es:
B.10.2. Sentencia do
for (expresin1; expresin2; expresin3)
La sentencia do acta como la sentencia while. La nica diferencia real es sentencia;|{<secuencia de sentencias>};
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: expresin1 se utiliza para inicializar la variable de control de bucle; a con-
tinuacin, expresin2 se evala; si es verdadera (distinta de cero), se eje-
do cuta la sentencia y se evala expresin3, y el control pasa de nuevo al prin-
sentencia cipio del bucle. La iteracin contina hasta que expresin2 es falsa (cero),
while (expresion); en cuyo momento el control pasa a la sentencia siguiente al bucle.
sentencia siguiente
Se ejecuta sentencia y a continuacin se evala expresin, y si es

Ejemplos
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 1. for (int i = 0; i < n; i++) //se realizan n iteraciones
control pasa a la sentencia siguiente. sentencias
2. Suma de 100 nmeros

Ejemplo
int n, suma =0;
int n, suma = 0; for (int i = 0; i < 100; i++)
int i = 1; {
cout << Entrar; char cad[80]=Cazorla;

cin >> n; int i;
suma += n;
} for(i=0; cad[i] !='\0'; i++)
;
B. 10.4. Sentencias break y continue

B.10.6. Sentencia return
El flujo de control ordinario de un bucle se puede romper o interrumpir
mediante las sentencias break y continue. La sentencia return detiene la ejecucin de la funcin actual y devuelve el
La sentencia break produce una salida inmediata del bucle for en que control a la funcin llamada. Su sintaxis es:
se encuentra situada:
return expresion;
for (i = 0; i < 100; ++i)
{ donde el valor de expresin se devuelve como el valor de la funcin.
cin >> x;
if (x < 0.0)
cout << salir del bucle << endl;
break; B.11. PUNTEROS (APUNTADORES)3
}
cout << sqrt (x) << endl; Un puntero o apuntador es una referencia indirecta a un objeto de un tipo
} especficado. En esencia, un puntero contiene la posicin de memoria de un
tipo dado.
La sentencia break tambin se utiliza para salir de la sentencia
switch.
La sentencia continue termina la iteracin que se est realizando y B.11.1. Declaracin de punteros
comenzar de nuevo la siguiente iteracin:
Los punteros se declaran utilizando el operador unitario. En las sentencias
for (i = 0; i < 100; ++i) siguientes se declaran dos variables: n es un entero, y p es un puntero a un
cin >> x; entero.
if (x < 0.0)
continue;
int n; //n es un tipo de dato entero
int *p; //p es un puntero a un entero
Advertencia: Una vez declarado un puntero, se puede fijar la direccin o posicin de

Una sentencia break puede ocurrir nicamente en el cuerpo de una memoria del tipo al que apunta.
sentencia for, while, do o switch.
Una sentencia continue slo puede ocurrir dentro del cuerpo de una p = &n; //p se fija a la direccin de n
sentencia for, while o do.
Un puntero se declara escribiendo:
NombreTipo *NombreVariable
B.10.5. Sentencia nula
La sentencia nula se representa por un punto y coma, y no hace ninguna 3 El trmino puntero es el ms utilizado en Espaa, mientras que en Latinoamrica se suele
accin. utilizar apuntador.

Una vez que se ha declarado un puntero, p, el objeto al que apunta se escri-

be *p y se puede tratar como cualquier otra variable de tipo NombreTipo. El nombre de un array se puede utilizar tambin como si fuera un punte-
ro al primer elemento del array.
int *p, *q, n; //dos punteros a int, y un int
n = -25; //n se fija a -25
*p = 105; //*p a 105 double a[10];
*q = n +*p; //*q a 80 double *p = a; //p y a se refieren al mismo array
C++ trata los punteros a tipos diferentes como tipos diferentes: p
int *ip; 0 1 2 3 4 5 6 7 8 9
double *dp;
Los punteros ip y dp son incompatibles, de modo que es un error escribir

Este elemento se puede llamar por: Este elemento se puede llamar por:
dp = ip; //Error, no se pueden asignar punteros a tipos
//diferentes
a[0], *p o bien p[0] a[6], *(p+6) o bien p[6]
Se pueden, sin embargo, realizar asignaciones entre contenidos, ya que Si nombre apunta al primer elemento del array, entonces nombre + 1
se realizara una conversin explcita de tipos. apunta al segundo elemento. El contenido de lo que se almacena en esa posi-
cin se obtiene por la expresin
*dp = *ip;
*(nombre+1)
Existe un puntero especial (nulo) que se suele utilizar con frecuencia en
programas C++. El puntero NULL tiene un valor cero, que lo diferencia de
todas las direcciones vlidas. El conocimiento nos permite comprobar si un Aunque las funciones no pueden modificar sus argumentos, si un array
puntero p es el puntero NULL evaluando la expresin (p==0). Los punteros se utiliza como un argumento de una funcin, la funcin puede modifi-
NULL se utilizan slo como seales de que ha sucedido algo. En otras pala- car el contenido del array.
bras, si p es un puntero NULL, es correcto referenciar *p.
B.11.3. Punteros a estructuras

B.11.2. Punteros a arrays
Los punteros a estructuras son similares y funcionan de igual forma que los
A los arrays se accede a travs de los ndices: punteros a cualquier otro tipo de dato.
int lista[5]; struct familia
lista[3] = 5; {
char *marido;
A los arrays tambin se puede acceder a travs de punteros: char *esposa;
char *hijo;
int lista[5]; //array de 5 elementos };
int *ptr; //puntero a entero
ptr = lista; //fija puntero al primer elemento del array familia mackoy; //mackoy estructura de tipo familia
ptr += 2; //suma 3 a ptr; ptr apunta al 4 elemento familia *p; //p, un puntero a familia
*ptr = 5; //establece el 4 elemento a 5 p = &mackoy; //p, contiene direccin de mackoy
p -> marido = Luis MackoY; //iniciacin Constantes de cadena

p -> esposa = Vilma Gonzlez; //iniciacin
p -> hijo = Luisito Mackoy; //iniciacin
Su declaracin es similar a
char *Cadena = Mi profesor;

B. 11.4. Punteros a objetos constantes
o bien su sentencia equivalente
Cuando se pasa un puntero a un objeto grande, pero se trata de que la fun-
cin no modifique el objeto (por ejemplo, en caso de que slo se desee
char VarCadena[] = Mi profesor;
visualizar el contenido de un array), se declara el argumento correspon-
diente de la funcin como un puntero a un objeto constante. La declara-
Si desea evitar que la cadena se modifique, aada const a la declaracin
cin es,
const NombreTipo *v; const char *VarCadena = Mi profesor;
establece v como un puntero a un objeto que no puede ser modificado. Un

ejemplo puede ser: Los punteros a cadena se declaran:
void Visualizar(const ObjetoGrande *v); char s[] o bien char *s
B.11.5. Punteros a void Punteros a cadenas
El tipo de dato void representa un valor nulo. En C++, sin embargo, el tipo de Los punteros de cadenas no son cadenas. Los punteros que localizan el pri-
puntero void se suele considerar como un puntero a cualquier tipo de dato. La mer elemento de una cadena almacenada.
idea fundamental que subyace en el puntero void en C++ es la de un tipo
que se puede utilizar adecuadamente para acceder a cualquier tipo de obje- char *varCadena;
const char *Cadenafija;
to, ya que es ms o menos independiente del tipo.
Un ejemplo ilustrativo de la diferencia de comportamiento en C y C++
es el siguiente segmento de programa.
Consideraciones prcticas
int main()
{ Todos los arrays en C++ se implementan mediante punteros:
void *vptr;
int *iptr; char cadenal[16]= Concepto Objeto;
char *cadena2 = cadena1;
vptr = iptr;
iptr = vptr; //Incorrecto en C++, correcto en C
iptr = (int *) vptr; //Correcto en C++ Las declaraciones siguientes son equivalentes y se refieren al carcter C:
...
} cadena1[0] cadena1 cadena2
B.11.6. Punteros y cadenas B.11.7. Aritmtica de punteros

Las cadenas en C++ se implementan como arrays de caracteres, como cons- Dado que los punteros son nmeros (direcciones), pueden ser manipulados
tantes de cadena y como punteros a caracteres. por los operadores aritmticos. Las operaciones que estn permitidas sobre
punteros son: suma, resta y comparacin. As, si las sentencias siguientes se ptr1 = new int; //memoria asignada para el objeto ptr1
ejecutan en secuencia: ptr2 = new double; //memoria ampliada para el objeto ptr2
*ptr1= 5;
char *p; //p contiene la direccin de un carcter *ptr2= 6.55;
char a[10]; // array de diez caracteres
p = &a[0]; //p apunta al primer elemento del array Dado que new devuelve un puntero, se puede utilizar ese puntero para
p++; //p apunta al segundo elemento del array inicializar el puntero en una sola definicin, tal como:
p++; //p apunta al tercer elemento del array
p--; //p apunta al segundo elemento del array int* p = new int;
Un ejemplo de comparacin de punteros es el siguiente programa: Si new no puede ocupar la cantidad de memoria solicitada, devuelve un
valor NULL. El operador delete libera la memoria asignada mediante new.
main (void) delete ptr1;
{
int *ptr1, *ptr2; Un pequeo programa que muestra el uso combinado de new y delete es,
int a[2] = {10,10};
ptr1 =a; #include <iostream.h>
cout << ptr1 es << ptr1 << *ptr1 es << *ptr1 << endl; void main (void)
ptr2 = ptr1 + 1; {
cout << ptr2 es << ptr2 << *Ptr2 es << *ptr2 << endl; char *c;
//comparar dos punteros c = new char[512];
if (ptr1 == ptr2) cin >> c;
cout << ptr1 no es igual a ptr2 \n; cout << c << endl;
if (*ptr1 == *ptr2)
delete c;
cout << ptr1 es igual a *ptr2 \n;
}
else
cout << ptr1 no es igual a *ptr2 \n;
} Los operadores new y delete se pueden utilizar para asignar memoria
a arrays, clases y otro tipo de datos.
int * i;
B. 12. LOS OPERADORES new Y delete i = new int[2][35]; //crear el array
//asignar el array
C++ define un mtodo para realizar asignacin dinmica de memoria, dife- ...
rente del utilizado en C, mediante los operadores new y delete. delete i; //destruir el array
El operador new sustituye a la funcin malloc tradicional en C, y el
operador delete sustituye a la funcin free tradicional tambin en C; new
asigna memoria y devuelve un puntero al objeto ltimamente creado. Su Sintaxis de new y delete:
sintaxis es:
new nombre_tipo new int new char[100]
new NombreTipo
new nombre_tipo inicializador new int(99) new char(C)
y un ejemplo de su aplicacin es: new nombre_tipo new (char*)
delete expresin delete p
int *ptr1; delete[] expresin delete[]
double *ptr2;
B. 13. ARRAYS
1. Los arrays se pueden pasar como argumentos a funciones.
Un array (matriz, tabla) es una coleccin de elementos dados del mismo
4 2. Las funciones no pueden devolver arrays.
tipo que se identifican por medio de un ndice. Los elementos comienzan 3. No est permitida la asignacin entre arrays. Para asignar un array a
con el ndice 0. otro se debe escribir el cdigo para realizar las asignaciones elemen-
to a elemento.
Declaracin de arrays
Una declaracin de un array tiene el siguiente formato:

B.14. ENUMERACIONES, ESTRUCTURAS Y UNIONES
nombreTipo nombreVariable[n]
En C++, un nombre de una enumeracin, estructura o unin es un nombre
Algunos ejemplos de arrays unidimensionales: de un tipo. Por consiguiente, la palabra reservada struct, union o enum
no son necesarias cuando se declara una variable.
int ListaNum[2]; //array de dos enteros El tipo de dato enumerado designa un grupo de constantes enteros con
char ListaNombres[10] ; //array de 10 caracteres nombres. La palabra reservada enum se utiliza para declarar un tipo de dato
enumerado o enumeracin. La sintaxis es:
Arrays multidimensionales son:
enum nombre
nombretipo nombreVariable[nl] [n2] ... [nx]; {
lista_simbolos
};
El siguiente ejemplo declara un array de enteros 4 10 3
int multidim[4][10][3];
donde nombre es el nombre de la variable declarada enumerada;
lista-smbolos es una lista de tipos enumerados, a los que se asigna valo-
El ejemplo tabla declara un array de 2 3 elementos. res cuando se declara la variable enumerada y puede tener un valor de ini-
cializacin. Se puede utilizar el nombre de una enumeracin para declarar
int tabla[2][3]; //array de enteros de 2x3 = 6 elementos
una variable de ese tipo (variable de enumeracin).
nombre var;
B.13.1. Definicin de arrays Considrese la siguiente sentencia:

Los arrays se inicializan con este formato:
enum color {Rojo, Azul, Verde, Amarillo};
int a[31 = {5, 10, 15};
char cad[5] = {a', 'b', 'c', 'd', 'e'}; Una variable de tipo enumeracin color es:
int tabla[2][3] = {{1,2,3}{3,4,5}};
color pantalla = Rojo; //Estilo C++
Las tres siguientes definiciones son equivalentes:
Una estructura es un tipo de dato compuesto que contiene una colec-
char saludo[5]= hola;
char saludo[] = hola;
cin de elementos de tipos de datos diferentes combinados en una nica
char saludo[5] = {'h', 'o', 'l', 'a', '\o'}; construccin del lenguaje. Cada elemento de la coleccin se llama miembro
y puede ser una variable de un tipo de dato diferente. Una estructura repre-
4 En Latinoamrica, este trmino se traduce al espaol por la palabra arreglo. senta un nuevo tipo de dato en C++.
La sintaxis de una estructura es: memoria. La unin annima no tiene asignado un nombre, y en consecuen-
cia se accede a los elementos de la unin directamente. La sintaxis de una
struct nombre unin annima es:
{
miembros union {
}; int nuevoID;
int contador;
};
Un ejemplo y una variable tipo estructura se muestra en las siguientes
sentencias: Las variables de la unin annima comparten la misma posicin de
memoria y espacio de datos.
struct cuadro{
int i; int main()
float f; {
}; union{
int x;
struct cuadro nombre; //Estilo C float y;
cuadro nombre; //Estilo C++ double z;
};
Una unin es una variable que puede almacenar objetos de tipos y x = 25;
tamaos diferentes. Una unin puede almacenar tipos de datos diferentes, y = 245.245; //el valor en y sobreescribe el valor de x
slo puede almacenar una cada vez, en oposicin a una estructura que alma- z = 9.41415; //el valor en z sobreescribe el valor de z
cena simultneamente una coleccin de tipos de datos. La sintaxis de una }
unin es:
union nombre { B.15. CADENAS

miembros
}; Una cadena es una serie de caracteres almacenados en bytes consecutivos de
memoria. Una cadena se puede almacenar en un array de caracteres (char)
Un ejemplo de estructura es: que termina en un carcter nulo (cero, \0).
union alfa { char perro[5] = {m, o, r, g, a, n}; //no es una cadena
int x; char gato[5] = {f, e, l, i, s, \0}; //es una cadena
char c;
};
Lectura de una cadena del teclado
Una declaracin de una variable estructura es:
alfa w; main()
{
El modo de acceder a los miembros de la estructura es mediante el ope- char cad[80];
rador punto: cout <<Introduzca una cadena:; //lectura del teclado
cin >> cad;
u.x = 145; cout <<Su cadena es:;
u.c = 'z'; cout << cad;
C + + admite un tipo especial de unin llamada unin annima, que return 0;

declara un conjunto de miembros que comparten la misma direccin de }
Esta lectura del teclado lee una cadena hasta que se encuentra el primer B.16.2. Definicin de funciones
carcter blanco. As, cuando se lee Sierra Mgina. Jan, en cad slo
se almacena Sierra. Para resolver el problema se utiliza la funcin gets La definicin de una funcin es el cuerpo de la funcin, que se ha declara-
(), que lee una cadena completa leda del teclado. El programa anterior se do con anterioridad.
escribe as para leer toda la cadena introducida:
double Media(double x, double y)
#include <iostream.h> //Devuelve la media de x e y
#include <stdio.h> {
return (x+y)/2.0;
main() }
{
char cad[80]; char LeerCaracter();
//Devuelve un carcter de la entrada estndar
cout << Introduzca una cadena:; {
gets(cad); char c;
cout << Su cadena es:; cin >> c;
cout << cad; return c;
}
return 0;
}
B.16.3. Argumentos por omisin

B.16. FUNCIONES
Los parmetros formales de una funcin pueden tomar valores por omisin,
Una funcin es una coleccin de declaraciones y sentencias que realizan una o argumentos cuyos valores se inicializan en la lista de argumentos forma-
tarea nica. Cada funcin tiene cuatro componentes: 1) su nombre; 2) el tipo les de la funcin.
de valor que devuelve cuando termina su tarea; 3) la informacin que toma
al realizar su tarea, y 5) la sentencia o sentencias que realizan su tarea. Cada int Potencia (int n, int k=2);
programa C++ tiene al menos una funcin: la funcin main.
Potencia(256); //256 elevado al cuadrado
B.16.1. Declaracin de funciones Los parmetros por omisin no necesitan especificarse cuando se llama
a la funcin. Los parmetros con valores por omisin deben estar al final de
En C + + se debe declarar una funcin antes de utilizarla. La declaracin de la lista de parmetros:
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 denomi- void func1 (int i=3, int j); //ilegal
na prototipo: void func2 (int i, int j=0, nt k=0); //correcto
void func3 (int i=2, int j, int k=0); //ilegal
void ImprimirValores (int cuenta, double cantidad=0.0);
tipoNombreFuncion (lista argumentos);
Ejemplos vlidos son: Llamadas a la funcin ImprimirValores son:
double Media(double x, double y); ImprimirValores (n,a);

void Print(char* formato, ...); ImprimirValores (n); //equivalente a ImprimirValores (n, 0.0)
extern max(const int*, int);
char LeerCaracter(); Otras declaraciones y llamadas a funciones son:
double f1(int n, int m, int p=0); //legal main (void)

double f2(int n, int m=1, int p=0); //legal {
double f3(int n=2, int m=1, int p=0); //legal int i = 0;
double f4(int n, int m=1, int p); //ilegal while (i < 5)
double f5(int n=2, int m, int p=0); //ilegal {
i = incrementar(i);
cout << i es: << i << endl;
B.16.4. Funciones en lnea (inline) }
}
Si una declaracin de funcin est precedida por la palabra reservada inli-

ne, el compilador sustituye cada llamada a la funcin con el cdigo que
B.16.5. Sobrecarga de funciones
implementa la funcin.
En C++, dos o ms funciones distintas pueden tener el mismo nombre. Esta
inline int Max(int a, int b)
propiedad se denomina sobrecarga. Un ejemplo es el siguiente:
{
if (a>b) return a; int max (int, int);
return b; double max (double, double);
}
o bien este otro:
main ()
{ void sumar (char i);
int x = 5, y = 4; void sumar (float j);
int z = Max(x,y);
} Las funciones sobrecargadas se diferencian en el nmero y tipo de argu-
mentos, o en el tipo que devuelven las funciones, y sus cuerpos son dife-
Los parmetros con valores por omisin deben entrar al final de la lista rentes en cada una de ellas.
de parmetros: las funciones f1, f2 y f3 son vlidas, mientras que las
#include <iostream.h
funciones f4 y f5 no son vlidas.
Las funciones en lnea (inline) evitan los tiempos suplementarios de las void suma (char);
llamadas mltiples a funciones. Las funciones declaradas en lnea deben ser void suma (float);
simples, con slo unas pocas sentencias de programa; slo se pueden llamar main (void)
un nmero limitado de veces y no son recursivas. {
int i = 65;
inline int abs(int i); int i = 6.5;
inline int min(int v1, int v2);
int mcd(int v1, int v2); suma(i);
suma(j);
Las funciones en lnea deben ser definidas antes de ser llamadas: }
void suma(char i)
#include <iostream.h> {
int incrementar(int i); cout << Suma interior(char) << endl;
}
inline incrementar(int i)
{ void suma(float j)
i++; {
return; cout << Suma interior (float) << endl;
} }
B.16.6. El modificador const y = x;

x = aux;
}
El modificador de tipos const se utiliza en C++ para proporcionar protec- //...
cin de slo lectura para variables y parmetros de funciones. Cuando se intercambio (i, j); //i, j intercambian sus valores
hace preceder un tipo de argumento con el modificador const para indicar
que este argumento no se puede cambiar, al argumento al que se aplica no
se puede asignar un valor ni cambiar. Si se necesita modificar un argumento de una funcin en su interior, el
argumento debe ser un tipo referencia en la declaracin de la funcin.
void copig (const char * fuente, char* dest);
void func_demo (const int i);
B.16.8. Paso de arrays

B.16.7. Paso de parmetros a funciones
Los arrays se pasan por referencia. La direccin del primer elemento del
En C++ existen tres formas de pasar parmetros a funciones: array se pasa a la funcin; los elementos individuales se pasan por valor. Los
arrays se pueden pasar indirectamente por su valor si el array se define
1. Por valor. La funcin llamada recibe una copia del parmetro, y este como un miembro de una estructura.
parmetro no se puede modificar dentro de la funcin:
void intercambio (int x, int y) //Paso del array completo. Ejemplo 1
{ #include <iostream.h>
int aux = y; void func](int x[]); //prototipo de funcin
y = x; void main(){
x = aux; int a[3] = {1,2,3};
} func1(a); //sentencias
//... func1(&a[0]); //equivalentes
intercambio (i, j); //las variables i, j no se intercambian }
void func(int x[]){

2. Por direccin. Se pasa un puntero al parmetro. Este mtodo permi- int i;
te simular en C/C++ la llamada por referencia, utilizando tipos pun- for (i = 0; i < 3; i+1)
teros en los parmetros formales en la declaracin de prototipos. Este cout << i << x[i] << '\n';
mtodo permite modificar los argumentos de una funcin. }
void intercambio (int*x, int*y)
{ El siguiente ejemplo pasa un elemento de un array:
int aux = *y;
*y = *x; #include <iostream.h>
*x = aux; {
} const int N=3;
//... void func2(int x);
intercambio (&i, &j); //i, j se intercambian sus valores void main() {
int a[N] = {1,2,3};
3. Por referencia. Se pueden pasar tipos referencia como argumentos de func2(a[2]);
funciones, lo que permite modificar los argumentos de una funcin. }
void intercambio (int &x, int &y); void func2(int x) {

{ cout << x << '\n';
int aux = y; }
B.17. CLASES public:

CCad(); //Constructor
-CCad(); //Destructor
Una clase es un tipo definido por el usuario que contiene un estado (datos) char *obtener(void) {return pDatos;}
y un comportamiento (funciones que manejan los datos). Una clase es como int obtenerlongitud(void) {return nLongitud;}
una estructura (struc) en C con la diferencia de que contiene funciones char * copy(char * s);
incorporadas. Adems, una clase puede tener algunos miembros que sean char * cat(char * s);
privados y a los que no se puede acceder desde el exterior de la clase. Esta }
propiedad se llama encapsulamiento y es un medio til para ocultar detalles
que el resto del programa no ve.
Las clases son distintas de los objetos que definen la clase como un tipo. B.17.1. Constructor
Las clases en C++ son comparables a los tipos primitivos tales como int,
char y double y un nombre de clase puede aparecer en cualquier texto que Un constructor es una funcin miembro que se llama automticamente
puede hacerlo int, char y double. Un objeto, en contraste, es como un cuando se crea un objeto; su nombre es el mismo que el nombre de la clase.
valor de un entero individual, un carcter o de coma flotante. Un objeto Cuando se crean objetos dinmicamente, se utilizan new y delete en vez de
tiene un estado particular, mientras que una clase es una descripcin gene- malloc y free. Los constructores no tienen tipo de retorno (ni incluso
ral del cdigo y los datos y no contiene informacin. Por cada clase puede void). La propia clase es el tipo de retorno implcito. Los constructores son
haber muchos objetos. Un objeto se conoce normalmente como una instan- como otras funciones miembro, aunque no se heredan. Es conveniente que
cia o un ejemplar. los constructores sean declarados como pblicos para que el resto del pro-
grama tenga acceso a ellos.
Sintaxis class CDibujo {

private:
Se puede declarar una clase en C++ utilizando class, struct o union: long coste;
int nEstrellas;
class | struct | union nombre[declaraciones_clase_base] CCad sDirector;
{ public:
declaraciones //Constructores
} [definiciones_de_objeto]; CDibujo();
CDibujo(long c, int n, CCad dir);
|, indica que una de las tres palabras reservadas se debe utilizar al CDibujo() {delete[ ];} / / destructor
principio de la declaracin. [ ], el contenido de su interior es opcional. };
//definicion de los constructores

Cada una de las tres palabras reservadas, class, struct y union, CDibujo::CDibujo() {
crea una clase con estas diferencias: }
El nivel de acceso a miembros por omisin es privado si se utiliza CDibujo::CDibujo(long c, int n, CCad dir){
class. El nivel de acceso a miembros es pblico si se utiliza union coste = c;
nEstrellas = n;
o struct.
sDirector = dir;
Las palabras reservadas struct y class crean un tipo similar a una }
estructura en C. Una union crea un tipo en la que todos los miembros
datos comienzan en la misma direccin en memoria.
class CCad{ B.17.2. Constructor por omisin
private:
char *pDatos; El constructor por omisin en cada clase es el constructor que no tiene argu-
int nLongitud; mentos. C++ lo invoca automticamente en las siguientes situaciones: cuan-
do se define un objeto de la clase sin argumentos, cuando un array de obje- Punto llamado figura, el constructor por omisin Punto se llama para
tos se declara con miembros no inicializados, o cuando el operador new se cada miembro del array
utiliza, pero no se especifica ningn argumento. La sintaxis de un construc-
tor por omisin es: Punto figura[3];
class()
vector::vector () { ... } B.17.5. Destructores
vector::vector(int i = 0) { ... }
Un destructor es una funcin miembro especial que se llama automtica-
class Punto {
mente cuando se desea borrar un objeto de la clase. El nombre de un des-
public:
tructor es el nombre de la clase, precedido por el carcter ~ (tilde). Si no se
Punto() declara explcitamente un destructor C++ crea automticamente uno vaco.
}
x = 0; class Punto{
y = 0; public:
} ~Punto()
private: {
int x; cout << Destructor Punto llamado \n;
}
int y;
//...
}; };
C++ crea automticamente un constructor por omision cuando no exis- Un destructor no tiene parmetros, ni incluso void y no tiene tipo de
te otro constructor. retorno. Una clase puede tener slo un constructor.
B.17.3. Constructor de copia B.17.6. Clases compuestas

Este constructor se crea automticamente por el compilador. El constructor
de copia se llama automticamente cuando se pasa un objeto por valor; se Cuando una clase contiene miembros dato que son por s mismos objetos de
construye una copia local del objeto. El formato es: otras clases, se denomina clase compuesta.
class DatosAcademicos { //...};
tipo: : tipo (const tipo& x)
Punto::Punto (const Punto &p2) class Direccion { // ...};
{
class Estudiante{
cerr << Se llama al constructor de copia.\n; public:
x = p2.x; Estudiante()
y = p2.y; }
return *this; LeerId(0);
} LeerNotaMedia(0.0);
}
el parmetro p2 no se puede modificar por la funcin. void LeerId(long);
void LeerNotaMedia(float);
private:
long id;
B.17.4. Arrays de objetos de clases DatosAcademicos da;
Direccion dir;
Un array de objetos de clases es til cuando se requieren instancias mlti- float NotaMedia;
ples de la misma clase. As por ejemplo, si se define un array de objetos };
B.17.7. Funciones miembro B.17.9. Funciones clases amigas (friend)

Las funciones miembro son funciones declaradas dentro de una clase. En Una amiga (friend) de una clase tiene acceso a todos los miembros de esa
consecuencia, ellas tienen acceso a miembros public, private y pro- clase. Si una funcin F, amiga de una clase C, utiliza un objeto de la clase C,
tected de esa clase. Si se definen dentro de la clase, se tratan como fun- es como si todos los miembros de C fueran declarados pblicos. El tipo ms
ciones inline y se tratan tambin como funciones sobrecargadas. comn de amigo de una clase es una funcin. Las clases tambin pueden ser
amigas de otras clases.
class vector { Para declarar una funcin como amiga de una clase, se ha de incluir un
public: prototipo de la funcin interior a la declaracin de la clase, precedida de la
vector(int n = 50); //constructor por defecto
palabra reservada friend.
vector (const vector& v) //constructor de copia
vector(const int a[ ], int n); class nombre {
... ...
int teo() const { return(size-1); } //funcin miembro en lnea friend prototipo_de_funcion;
private: ...
... };
};
para declarar una clase como amiga, se utiliza la siguiente sintaxis:
Las funciones miembro se invocan normalmente mediante el uso de
class nombre {
operadores punto (.) o bien ->. ...
vector a (5O) , b; friend class nombre_clase;
vector* ptr_v = &b; };
int teo15 = a.teo();
teo15 = ptr_v -> teo()
Funcin amiga
class Estudiante;
B.17.8. Funciones miembro constante class Empleado {
public:
Una funcin miembro constante es aquella que garantiza no se modifica el Empleado (long idVal);
estado del objeto de la clase til. friend void RegistrarEstudiante (Estudiante &S,
Empleado &E, float tasa);
class Punto { private:
public: long id; //nmero de matrcula
Punto (int xval, int yval); float PagoTasa;
};
int LeerX() const;
void Fijarx (int xval);

//... Clase amiga
};
class clase_1 {
La palabra reservada const debe aparecer tambin en la implementa- friend class clase_2;
cin de la funcin //...
};
int Punto::LeerX() const
{ class clase_2 {
return x; friend class clase_3;
} };
B.17.10. El puntero this class D : public B1, public B2, private B3 {

...
};
Dentro de una funcin miembro, la palabra reservada this es el nombre de
un puntero implcito al objeto actual. Cuando se desea utilizar el puntero La palabra reservada virtual es un especificador de funcin que pro-
oculto en el cdigo de la funcin miembro, se utiliza la palabra reservada porciona un mecanismo para seleccionar en tiempo de ejecucin la funcin
this. La mayora de las veces, el uso de this es innecesario, ya que C++ miembro apropiada a partir de la clase base y clases derivadas
supone el uso de this siempre que se refiera a miembros dato.
class D : public virtual B1, public virtual B2 {
Cpunto::fijar(double nuevox, double nuevoy) { ...
};
x = nuevox; //x significa lo mismo que this-> x
y = nuevoy; //y significa lo mismo que this-> y class Estudiante : public virtual Persona {
} //...
class Empleado : public virtual Persona {
//...
B.18. HERENCIA
B.19. SOBRECARGA DE OPERADORES
Una herencia es una relacin es-un entre dos clases, en la que una nueva
clase se deriva de otra clase denominada clase base. La nueva clase, se La sobrecarga de operadores se refiere a la tcnica que permite proveer un
denomina clase derivada. La relacin es-un se manifiesta como un estu- nuevo significado a los operadores estndar tales como =, < <, ... Dicho
diante de doctorado es-un estudiante que est escribiendo una tesis. de otro modo, se pueden definir funciones operador para sus clases.
Una funcin operador es una funcin cuyo nombre consta de la palabra
Sintaxis reservada operator seguida por un operador binarlo o unitario con el for-
mato:
class nombre_clase_derivada: (public|protected|private)
operator operador
clase_base {
declaraciones // Sobrecarga de operadores aritmticos y
}; // de asignacin
clase_base es el nombre de la clase del que se deriva la clase actual class Punto
derivada los especificadores de acceso pueden ser public, pro- }
tected o private. Un miembro public es accesible a travs de su //...
mbito; los miembros de clase_base se heredan sin modificacin en su public:
estado. Un miembro privado (private) es accesible a otras funciones //...
miembro dentro de su propia clase. Un miembro protegido (protected) es Punto operator * (const Punto& p);
accesible a otras funciones miembro dentro de su clase y a cualquier clase Punto operator / (const Punto& p);
Punto operator += (const Punto& p);
derivada de ella. Los modificadores de acceso se pueden utilizar dentro de
//...
una declaracin de una clase en cualquier orden y con cualquier frecuencia. };
//implementacin de funcin miembro sobrecargada
class D : public A { //p1 * p2
... inline Punto Punto::operator * (const Punto& p)
};
{
return Punto (x * p.x, y * p.y, z * p.z);
La herencia mltiple permite que una clase sea derivada de ms de una }
clase base. En el siguiente ejemplo, D es la clase derivada, y Bl, B2 y B3 son //p1 / p2
clases base. ...
Una vez declarada y definida la clase se pueden escribir expresiones Un ejemplo que ilustra una funcin operador de asignacin
tales como:
class Cpunto {
Punto p, q, r; private:
//... double x, y;
r = p * q; //multiplicacin public:
//... Cpunto& operator = (const Cpunto& punto);
r = p + = q; //asignacin encadenada y aritmtica ...
//... };
B.19.1. Funciones operador unitario B.19.4. Operadores de incremento y decremento

@operando @, operador Los operadores incremento (+ +) y decremento ( ) siguen la mayora de
El compilador evala la expresin llamando a una de las siguientes fun- las reglas de los operadores unitarios, pero tambin pueden ser prefijo y
ciones, dependiendo de la que est definida: postfijo. Los siguientes ejemplos ilustran las versiones prefijas y postfijas
del operador de incremento (+ +).
tipo_retorno tipo::operator@()
tipo_retorno operator@ (tipo) class Cpunto {
private:
Dependiendo del propio, la expresin que utiliza un operador unitario double x, y;
puede ser de la forma public:
Cpunto& operator++(); //prefijo
operator@ Cpunto operator++(int); //postfijo
};
class P {
B.19.2. Funciones operador binario public:
void operator++(int);
Se puede escribir una funcin operador binario para un operador (tal como void operator--(int);
+, , *, ) que C++ acepta como un operador binario };
operando1@ operando2 @ operador
el compilador evala la expresin llamando a una de las siguientes funcio- B.20. PLANTILLAS (templates)
nes, dependiendo de en cul est definida
La palabra reservada template se utiliza para implementar tipos
tipo_retorno tipo1::opera tor@ (tipo2) parametrizados o plantillas. C++ reconoce dos tipos de plantillas: planti-
tipo_retorno tipo2::operator@ (tipo1, tipo2) llas de clases y plantillas de funciones.
tipol y tipo2 son los tipos de operando1 y operando2, respectiva-
Sintaxis
mente.
template < argumentos_plantilla > //plantilla de clase
declaracin_de_clase
B.19.3. Funciones operador de asignacin
template < argumentos_plantilla > //plantilla de funcin
La declaracin de esta funcin es: definicin_funcin
class & clase::operator = (const clase &) < argumentos_plantilla > es class arg_nombre
B.20.1. Plantillas de funciones T puede ser un tipo o una expresion. Las plantillas se instancian para
crear clases a partir de ellas.
Una plantilla de funcin debe tener al menos un tipo de parmetro, pero
puede tener ms. Su formato es: MiClase <int> x;
MiClase <Estudiante> miEstudiante;
template <classT>
tipo-retorno nombre-funcin(T parmetro) Una plantilla puede tener mltiples parmetros
T es un parmetro de plantilla template <class T1, class T2>

class Circulo {
//...
template <class T>
private:
void Presentar (const T &valor)
Tl x;
{
T2 y;
cout << valor;
T2 radio;
}
};
//...
Una funcin plantilla puede tener parmetros adicionales Circulo <int, long> c;
Circulo <unsigned, float> D;
template <class T>
void Intercambio(T& x, T& y) Un ejemplo clsico es una Pila de datos
{
T aux;
template <class T>
aux = x;
class pila {
x = y;
T *pilap;
y = aux;
int longitud;
}
int indice;
public:
int m, n;
T sacar(void) {return pilap[--indice];}
Estudiante S1;
void meter(T item){pilap[indice++] = item; }
Estudiante S2;
...
//...
};
Intercambio(m, n); //llamada con enteros
Intercambio(S1, S2); //llamada con estudiantes
Esta plantilla se puede instanciar del modo siguiente:
pila<int> elementos(30); //pila de enteros

pila<CCad> cadenas(20); //pila de objetos Ccad
B.20.2. Plantillas de clases
Las plantillas de clases ofrecen la posibilidad de generar nuevas clases. Los
tipos ms comunes de plantillas son clases contenedoras, tales como arrays, B.21. EXCEPCIONES
listas y conjuntos. Cada plantilla puede trabajar con una variedad de tipos de
datos. El formato bsico para definir una plantilla de clase es: El manejo o manipulacin de excepciones es el mecanismo para detectar y
manipular excepciones. Un manipulador de excepciones es un bloque de
template <class T> cdigo que procesa condiciones de error especficas. Una excepcin es, casi
class MiClase { siempre, un error en tiempo de ejecucin, tal como falta de memoria,
//... fallo al abrir un archivo, errores de rango de subndice o divisin por
}; cero.
En C++, cuando se genera una excepcin, el error no se puede ignorar catch (const char* mensaje)
o terminar el programa. Un programa lanza o dispara (throws) una excep- {
cin en el punto en que se detecta el error. Cuando sucede esto, un progra- cerr << mensaje << endl;
exit(1);
ma C++ busca automticamente el manipulador de excepciones, que res-
}
ponde a la excepcin de algn modo apropiado. Esta respuesta se denomina
capturar una excepcin (catching). Si no se puede encontrar un manipu-
lador de excepciones el programa terminar.
B.21.3. Especificacin de excepciones
Sintcticamente, una especificacin de excepciones es parte de una decla-
B.21.1. Lanzamiento de excepciones racin de funciones y tiene el formato:
Pueden ocurrir muchos tipos diferentes de excepciones, de modo que cuando
cabecerafuncin throw (lista de tipos)
se lanza una excepcin, una expresin throw excepcin (o slo throw)
identifica el tipo de excepcin. La sintaxis adopta dos formatos:
La lista de tipos son los tipos que pueden tener una sentencia throw
throw expresin dentro de la llamada de la funcin; si la lista es vaca, el compi-
throw expresin lador puede suponer que ninguna sentencia throw se ejecutar por la fun-
//lanzamiento de una excepcin, creando un subndice cin, bien directa o bien indirectamente
//est fuera de rango
const unsigned LongArray = 500; void demo() throw(int, desbordamiento);
unsigned i; void nodemo(int i) throw();
.
.
. As, una declaracin de funcin:
if (i > = LongArray) //es el subndice vlido
throw ErrorRango; void Demo() throw (A, B)
{
La palabra reservada try, junto con las sentencias que le siguen ence- //...
rradas entre llaves, se llama un bloque try. Debe ser seguido inmediatamen- }
te por uno o ms manejadores de excepciones. Cada manejador de excep-
ciones comienza con la palabra reservada catch seguida por un bloque que se tratar del siguiente modo:
contiene sentencias.
void Demo()
try {
{ try {
lista_de_sentencias
//...
}
llamada a Demo()
catch (lista_de_parmetros){
}
lista_de_sentencias
} catch (A)
catch (lista_de_parmetros){ throw;
lista_de_sentencias }
} catch (B)
}
//...
}
B.21.2. Manejador de excepciones catch (...)
{
Un bloque catch se conoce tambin como manejador de excepciones y se //unexpected
parece a una declaracin de funcin de un argumento sin un tipo de retorno. }
Si una funcin no est especificada con una declaracin throw puede class range_error : public runtime-error
lanzar cualquier excepcin. La declaracin throw() indica que una funcin {
no lanza ninguna excepcin. public:
range_error;
Si una funcin lanza una excepcin que no est en su declaracin, se llama
{
a la funcin unexpected. En la mayora de las implementaciones, unexpec- const string & que_arg;
ted llama a terminate que llama a abort. La funcin set_unexpected }
permite definir el manejo de excepciones no previstas. Todas estas declaracio- };
nes de funciones se encuentran en al archivo except o bien except.h.
B.21.5. Resumen de sintaxis de excepciones

B.21.4. Excepciones en la biblioteca estndar
throw valor;
Las excepciones de la biblioteca estndar se derivan de la clase base excep- try {
tion. Dos de las clases derivadas son logic_error y runtime_error. sentencias
Los errores de tipo lgico incluyen bad_cast, out_of range y bad_ {
catch (tipo_excepcin){
typeid, y los errores de tiempo de ejecucin incluyen range_error,
sentencias
overflow_error y bad_alloc.
}
class logic_error: public exception try {
{ sentencias
public: }
logic_error; catch (dec_argumentos1) {
{ sentencias
const string & que_arg; //... }
} catch (dec_argumentos2) {
}; sentencias
}
...
Ejemplo de excepcin lgica
throw;
Los errores lgicos informan de un problema que es detectable antes de que
un programa se ejecute
B.22. ESPACIO DE NOMBRES (Namespaces)
class doman-error : public logic_error
{ Un espacio de nombres (namespace) es un mecanismo para expresar agru-
public: pamientos lgicos. Es decir, si algunas declaraciones se pueden agrupar
domain_error lgicamente de acuerdo a algn criterio, se pueden poner en un espacio de
{
nombres comn que expresen dicho hecho. La palabra reservada namespa-
ce define un espacio de nombres
const string & que_arg
}
}; namespace nombre {
cuerpo_espacio_de_nombres
}
Ejemplo de excepcin de tiempo de ejecucin
Este formato crea un espacio de nombre con el calificador nombre. Den-
Los errores en tiempo de ejecucin ocurren durante la ejecucin del pro- tro de los caracteres llave ({ }), cuerpo_espacio_de_nombres puede
grama incluir variables, definiciones de funciones y prototipos, estructuras, clases,
enumeraciones (enum), definiciones de tipos (typedef) o bien otras definiciones B.22.2. Acceso a los miembros de un espacio de nombre
de espacios de nombres. Obsrvese que un espacio de nombre no termina con
un punto y coma. Las definiciones de espacio de nombres aparecen en archi- El operador de resolucin de mbito proporciona acceso a miembros de un
vos de cabecera y en mdulos independientes con definiciones de funciones. espacio de nombre.
Ejemplo nombre_espacio_de-nombre::nombre_miembro
namespace Rojo {
nombre_espacio_de_nombre es un cualificador de espacio de nombre
int j;
void imprimir(int i) definido con anterioridad y nombre_miembro debe estar declarado dentro
{cout << Rojo::imprimir() << i << endl;} de nombre_espacio_de_nombre.
}
void Azul::imprimir(int k){
namespace Azul { cout << Azul::imprimir() = << k << endl;
int j;
}
void imprimir(int);
}
void sub1() {...} //puede acceder a espacio de nombres El operador de resolucin de mbito asocia imprimir() con el espacio
//Azul y Rojo de nombre Azul; sin el mismo, el compilador define imprimir() como
void sub() {...} //puede acceder a espacio de nombres una funcin global.
//Azul y Rojo
Los espacios de nombre Rojo y Azul tienen dos miembros con el

mismo nombre: entero j y funcin imprimir() (normalmente estas defi- B.22.3. Espacio de nombre sin nombres
niciones no podran convivir en un espacio global, pero un espacio de nom-
bre elimina ese problema). Un espacio de nombre puede incluir definiciones Es muy til, en ocasiones, envolver un conjunto de declaraciones en un
de funciones y prototipos de funciones. Las definiciones de funciones de espacio de nombre simplemente para proteger frente a la posibilidad de
sub1() y sub2() tienen acceso a todos los miembros del espacio de nom- conflictos de nombres. El formato es:
bres Rojo y Azul.
namespace {
cuerpo_nombre_de_espacio
B.22.1. Extensiones }
Los espacios de nombre son extensibles; es decir, se pueden aadir declara- Todos los miembros definidos en cuerpo_nombre_de_espacio estn
ciones posteriores a espacios de nombre definidos anteriormente. Las exten- en un espacio de nombre sin nombre que se garantiza nico para cada uni-
siones del espacio de nombres pueden aparecer tambin en archivos inde- dad de traduccin.
pendientes de la definicin original del espacio de nombre.
namespace Azul{ //definicin original de espacio de nombre
int j; B.22.4. Directivas using
void imprimir (int);
} El acceso a los miembros de espacio de nombre puede tener dificultades,
especialmente con calificadores de espacio de nombre largos y espacios de
namespace Azul{ //extensin del espacio de nombre nombre anidados. Las directivas using proporcionan acceso a todos los
char car; miembros del espacio de nombre sin un cualificador de espacio de nombre
char bufer[20];
y el operador de mbito. El formato es:
}
... using namespace nombre;
El cualificador nombre debe ser un nombre de espacio definido anterior- // uso de alias para abreviaturas
mente. Pueden aparecer las directivas using en mbitos locales y globales. namespace UPSAM = Universidad_Pontificia_deSalamanca_enMadrid;
UPSAM::String c3 = Fundacin;
UPSAM::String c4 = Pablo VI;
B.22.5. Declaraciones using namespace Geometria{
struct Punto {
Las directivas using hacen a todos los miembros del espacio de nombre double x, y;
accesibles sin cualificacin. En contraste, las declaraciones using cualifi- };
can slo miembros individuales de espacio de nombre. El formato es: double pendiente (Punto, Punto);
}
using nombre_espacio_de_nombre::nombre-miembro;
El espacio de nombres incluye un tipo Punto y una funcin pendien-
namespace Negro{ //define espacio de nombre Negro te. La implementacin del archivo geometria.c
int j;
void imprimir(int); // geometria.c
char car; #include geometria.h
}
namespace Blanco{ namespace Geometria { // extensin de espacio de nombre
int j; Punto origen = {0, 0};
void imprimir(int); }
double vision; double Geometria::pendiente (Punto p1, Punto p2){
} double dy = p2.y - p1.y;
double dx = p2.x - p1.x;
using Blanco::vision; if (dx = = 0)
throw pendiente() : pendiente no definida;
return dy / dx;
}
B.22.6. Alias de espacio de nombres
Una extensin del espacio de nombre ha aadido un miembro origen
Los alias de espacio de nombres crean nombres sinnimos de espacio de a Geometria. La funcin pendiente() calcula la pendiente de los puntos
nombres. Es buena prctica utilizar alianzas cuando un espacio de nombre pl y p2 y levanta una excepcin de cadena de caracteres si el denominador
tiene un nombre largo. El formato es: de la pendiente es cero.
namespace nombre_alias = nombre_de_espacio;
B.22.7. Espacio de nombres anidados

Ejemplo
Los espacios de nombres son ilegales en el interior de funciones, pero pue-
namespace Universidad_Pontificia-deSalamanca_enMadrid{ den aparecer en otras definiciones de espacio de nombre.
//...
} namespace Exterior
int i, j;
Universidad_Pontificia_deSalamanca_enMadrid::String c3 =
namespace Interior
Fundacin; const int Max = 20;
Universidad_Pontificia_deSalamanca_enMadrid::String c4 = char car;
Pablo VI; char bufer[Max];
void imprimir();
El cdigo anterior es poco prctico en cdigo real; un alias corto resuel- }
ve el inconveniente }
El acceso a los miembros de un espacio de nombres anidados se resuel- namespace {

ve con el operador de resolucin de mbito (::) Punto origen = {10, 10};
}
void Exterior::Interior::imprimir() { int main()
for (int i = 0; i < Max; i++) //i es local al bucle for {
cout << bufer[i] << ; try {
cout << endl; Punto a = {3, 5}
} Punto b = {6, 10};
cout << La lnea ab tiene la pendiente
<< pendiente(a,b) << endl;
cout << La linea origen_a tiene la pendiente
B.22.8. Un programa completo con espacio de nombres << pendiente (origen,a)
<< endl;
El archivo de cabecera geometria.h define un espacio de nombre para una }
biblioteca de geometria (geometria). catch (char *msg) {
cout << msg << endl;
#ifndef GEOMETRIAH return 1;
#define GEOMETRIAH }
// archivo geometria.h return 0;
}
Aplicacin. Utilizar el espacio de nombre Geometria para calcular pen- #endif
dientes de las variables Punto.
Al ejecutar el programa se obtendr:
#include geometria.h La lnea ab tiene la pendiente 1.66667
namespace Geo = Geometria; //alias La lnea origen_a tiene la pendiente 0.714286
using Geo::Punto;
using Geo::pendiente;

Guía de Sintaxis Ansi/Iso Estándar C++: Apéndiceb

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Guía de Sintaxis Ansi/Iso Estándar C++: Apéndiceb

Cargado por

Copyright:

Formatos disponibles

APNDICE B

GUA DE SINTAXIS ANSI/ISO

B.1. Elementos del lenguaje. B.12. Los operadores new y delete.

C++ es considerado un C ms grande y potente. La sintaxis de C++ es una a b c d e f g h i j k l m n o p q r s t u v w x y z

Los tipos derivados en C++ pueden ser: B.3. CONSTANTES

B.3.1. Declaracin de constantes con const B.5. DECLARACIN DE VARIABLES

En C++, las declaraciones de variables se pueden situar en cualquier

B.6. OPERADORES variable-

C++ proporciona diferentes operadores que relacionan operaciones aritm-

-i + w; //menos unitario ms unitario Otros ejemplos de expresiones vlidas y no vlidas son:

B.6.3. Operadores lgicos y relacionales x > y 1, si x excede a y, si no 0

2. Operacin lgica OR (||). Si expr1 toma un valor distinto de cero, Ejemplos

C++ proporciona operadores de manipulacin de bits, as como operadores

Ejemplos < <= > >= Izquierda-Derecha 7

x Cambia los bits 1 a 0 y los bits 0 a 1 == != Izquierda-Derecha 8

Ejemplo Si se desea visualizar el valor del objeto int llamado i, se escribe la

B.6.7. Sobrecarga de operadores El siguiente programa visualiza en pantalla una frase:

Otro programa que muestra la conexin en cascada es

B.7.3. Manipuladores Algunas sentencias vlidas en C++ son:

#include <iostream.h> B.8.2. Sentencias de expresin

C++ permite asignaciones mltiples en una sentencia. Ejemplo 2

if ((altura - 5) < 4){

if (a < 0) if (cantidad > 10){

B.9.2. Sentencias de alternativa mltiple: switch B.10. BUCLES: SENTENCIAS REPETITIVAS

El siguiente ejemplo visualiza los cuadrados de 2 a 10:

Se ejecuta sentencia y a continuacin se evala expresin, y si es

2. Suma de 100 nmeros

cout << Entrar; char cad[80]=Cazorla;

B. 10.4. Sentencias break y continue

Advertencia: Una vez declarado un puntero, se puede fijar la direccin o posicin de

accin. utilizar apuntador.

Una vez que se ha declarado un puntero, p, el objeto al que apunta se escri-

C++ trata los punteros a tipos diferentes como tipos diferentes: p

Los punteros ip y dp son incompatibles, de modo que es un error escribir

B.11.3. Punteros a estructuras

p -> marido = Luis MackoY; //iniciacin Constantes de cadena

char *Cadena = Mi profesor;

const NombreTipo *v; const char *VarCadena = Mi profesor;

establece v como un puntero a un objeto que no puede ser modificado. Un

void Visualizar(const ObjetoGrande *v); char s[] o bien char *s

B.11.5. Punteros a void Punteros a cadenas

B.11.6. Punteros y cadenas B.11.7. Aritmtica de punteros

Una declaracin de un array tiene el siguiente formato:

B.13.1. Definicin de arrays Considrese la siguiente sentencia:

union nombre { B.15. CADENAS

C + + admite un tipo especial de unin llamada unin annima, que return 0;

B.16.3. Argumentos por omisin

Ejemplos vlidos son: Llamadas a la funcin ImprimirValores son:

double Media(double x, double y); ImprimirValores (n,a);

double f1(int n, int m, int p=0); //legal main (void)

Si una declaracin de funcin est precedida por la palabra reservada inli-

B.16.6. El modificador const y = x;

B.16.8. Paso de arrays

void func(int x[]){

void intercambio (int &x, int &y); void func2(int x) {

B.17. CLASES public:

Sintaxis class CDibujo {

//definicion de los constructores

B.17.3. Constructor de copia B.17.6. Clases compuestas

B.17.7. Funciones miembro B.17.9. Funciones clases amigas (friend)

void Fijarx (int xval);

B.17.10. El puntero this class D : public B1, public B2, private B3 {

B.19.1. Funciones operador unitario B.19.4. Operadores de incremento y decremento

const NombreTipo v; const char VarCadena = Mi profesor;

void Visualizar(const ObjetoGrande v); char s[] o bien char s