¡Descarga iNFORMATICA APRENDER C++ y más Apuntes en PDF de Informática solo en Docsity!
B.1. Elementos del lenguaje. B.2. Tipos de datos. B.3. Constantes. B.4. Conversión de tipos. B.5. Declaración de variables. B.6. Operadores. B.7. Entradas y salidas básicas. B.8. Sentencias. B.9. Sentencias condicionales: if. B.10. Bucles: sentencias repetitivas. B.11. Punteros (apuntadores).
B.12. Los operadores new y delete. B.13. Array. B.14. Enumeraciones, estructuras y uniones. B.15. Cadenas. B.16. Funciones. B.17. Clases. B.18. Herencia. B.19. Sobrecarga de operadores. B.20. Plantillas (templates). B.21. Excepciones. B.22. Espacio de nombres (Namespaces).
A P É N D I C E B
G U Í A D E S I N T A X I S A N S I / I S O
E S T Á N D A R C + +
C++ es considerado un C más grande y potente. La sintaxis de C++ es una
extensión de C, al que se han añadido numerosas propiedades, fundamen-
talmente orientadas a objetos. C ANSI 1 ya adoptó numerosas características
de C++, por lo que la emigración de C a C++ no suele ser difícil.
En este apéndice se muestran las reglas de sintaxis del estándar clásico de
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. ELEMENTOS DEL LENGUAJE
Un programa en C++ es una secuencia de caracteres que se agrupan en
componentes léxicos (tokens) que comprenden el vocabulario básico del
lenguaje. Estos componentes de léxico son: palabras reservadas, identifica-
dores, constantes, constantes de cadena, operadores y signos de puntuación.
B.1.1. Caracteres
Los caracteres que se pueden utilizar para construir elementos del lenguaje
(componentes léxicos o tokens) son:
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 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 0 1 2 3 4 5 6 7 8 9
- / = ( ) { } [ ] < > ´ ”! @ =/ $ ^ & % - :. , ;? \ |
caracteres espacio (blancos y tabulaciones).
B.1.2. Comentarios
C++ soporta dos tipos de comentarios. Las líneas de comentarios al estilo C
y C ANSI, tal como:
/* Comentario estilo C/, se puede extender / hasta que aparece la marca de cierre */ // Este tipo de comentario termina al final de la línea // Sólo es posible una línea de comentario
La versión /.../ se utiliza para comentarios que excedan una línea
de longitud, y la versión //... se utiliza sólo para comentarios de una línea.
Los comentarios no se anidan.
B.1.3. ldentificadores
Los identificadores (nombres de variables, constantes, etc.) deben comenzar
con una letra del alfabeto (mayúscula o minúscula) o con un carácter subra-
CONTENIDO
(^1) Se utiliza indistintamente los términos ANSI C (nombre inglés) y C ANSI, traducción al español muy usada en la vida profesionbal y académica.
yado y pueden tener uno o más caracteres. Los caracteres segundo y poste-
riores pueden ser letras, dígitos o un subrayado, no permitiéndose caracte-
res no alfanuméricos ni espacios.
test_prueba //legal X123 //legal multi_palabra //legal var25 //legal 15var //no legal
C++ es sensible a las mayúsculas. Las letras mayúsculas y minúsculas se
consideran diferentes.
Paga_mes es un identificador distinto a paga_mes
Buena práctica de programación aconseja utilizar identificadores sig-
nificativos que ayudan a documentar un programa.
nombre apellidos salario precio_neto Edad Longitud Altura Salario_Mes
B.1.4. 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 B.1 enumera las palabras reservadas de C++ según el ARM^2.
Los diferentes compiladores comerciales de C++ pueden incluir,
además, nuevas palabras reservadas. Estos son los casos de Borland, Micro-
soft y Symantec.
564 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
TABLA B.1. 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.
2 Siglas del libro de Margaret Ellis y Bjarne Stroustrup en el que se definen las reglas de
sintaxis del lenguaje C++ estándar, Annotated Reference Manual, Addlson-Wesley, 1992.
TABLA B.2. Palabras reservadas de Borland C++ 5 _ _asm _ _cdecl _ _cs _ _declspec _ _ds _ _es _ _except _ _export _ _far _ _fastcall _ _finally _ _huge _ _import _ _interrupt _ _loadds _ _near _ _pascal _ _rtti _ _saveregs _ _seg _ _ss _ _stdcall _ _thread _ _try _ asm _cdecl _cs _ds _es _export _far _fastcall _huge _import _interrupt _loadds _near _pascal _saveregs _seg ss stdcall asm auto bool break case catch cdecl char class const const_cast continue default delete do double dynamic_cast else enum explicit extern false far float for friend goto huge if inline int interrupt long mutable namespace near new operator pascal private protected public register reinterpret cast return short signed sizeof static static_cast struct switch template this throw true try typedef typeid typename union unsigned using virtual void volatile wchar t while
TABLA B.3. Palabras reservadas de Visual C++ 6 _asm _fastcall public signed _except new unsigned void _virtual_inheritance typedef using directive do throw class default _leave case goto _int8 struct _finally register sizeof auto operator using declaration volatile explicit typeid uuid double mutable const delete long true if _intl6 switch catch reinterpret_cast static template flota return wmain _based private _uuidof dynamic-cast extern typename dl1export man naked const-cast _int32 _multiple try inline _inheritance static-cast this _cdecl _inline while bool for short else false protected virtual enum namespace union dllimport -single-inheritance _try continue _int thread char _dec1spec _stdcall break friend int xalloc
B.3.1. Declaración de constantes con const
En C++, los identificadores de variables/constantes se pueden declarar cons-
tantes, significando que su valor se inicializa pero no se puede modificar.
Estas constantes se denominan simbólicas. Esta declaración 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++ también para propor-
cionar protección de sólo lectura para variables y parámetros de funciones.
Las funciones miembro de una clase que no modifican los miembros dato a
que acceden pueden ser declarados const. Este modificador evita también
que parámetros parados por referencia sean modificados:
void copy (const char* fuente, char* destino);
B.3.2. Declaración de constantes con define#
C++ soporta también el método tradicional de declaración de constantes,
aunque ahora está obsoleto. Para declarar una constante por este método se
debe realizar con la palabra reservada #define.
#define estudiantesPorClave 50 #define PI 3. #define hex 16
B.4. CONVERSIÓN DE TIPOS
Las conversiones explícitas se fuerzan mediante moldes (casts). La con-
versión forzosa de tipos de C tiene el formato clásico:
(tipo) expresión
C++ ha modificado la notación anterior por una notación funcional
como alternativa sintáctica:
nombre del tipo (expresión)
Las notaciones siguientes son equivalentes:
z = float(x); //notación de moldes en C++ z = (float)x; //notación de moldes en C
B.5. DECLARACIÓN DE VARIABLES
En C ANSI, todas las declaraciones de variables y funciones se deben hacer al
principio del programa o función. Si se necesitan declaraciones adicionales, el
programador debe volver al bloque de declaraciones al objeto de hacer los ajus-
tes o inserciones necesarios. Todas las declaraciones deben hacerse antes de
que se ejecute cualquier sentencia. Así, la declaración típica en C++
NombreTipo NombreVariable1, NombreVarible2, ...
proporciona declaraciones tales como:
int saldo, meses; double clipper, salario;
Al igual que en C, se pueden asignar valores a las variables en C++:
int mes = 4,dia, anyo = 1995; double salario = 45.675;
En C++, las declaraciones de variables se pueden situar en cualquier
parte de un programa. Esta característica hace que el programador declare
sus variables en la proximidad del lugar donde se utilizan las sentencias de su
programa. El siguiente programa es legal en C++ pero no es válido en C:
#include int main() { int i; for (i=0; i < 100; ++i) cout << i << endl;
double j; for (j = 1.7547; j < 25.4675; j+= .001) cout << i << endl; }
El programa anterior se podría rescribir, haciendo la declaración y la
definición dentro del mismo bucle:
int main() { for (int i=0; i<100; ++i) cout << i << endl;
for (double j - 1.7545; j<25.4675;j += .001) cout << i << endl; }
566 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
B.6. OPERADORES
C++ es un lenguaje muy rico en operadores. Se clasifican en los siguientes
grupos:
- Aritméticos.
- Relacionales y lógicos.
- Asignación.
- Acceso a datos y tamaño.
- Manipulación de bits.
- Varios.
Como consecuencia de la gran cantidad de operadores, se producen
también una gran cantidad de expresiones diferentes.
B.6.1. Operadores aritméticos
C++ proporciona diferentes operadores que relacionan operaciones aritmé-
ticas.
TABLA B.6. Operadores aritméticos en C++
Operador Nombre Propósito Ejemplo
+ Más unitario Valor positivo de x x = + y + 5
- Negación Valor negativo de x X = - y;
+ Suma Suma x e y z = x + y;
- Resta Resta y de x z = x - y ;
* Multiplicación Multiplica x por y z = x * y;
/ División Divide x por y z = x/y;
% Módulo Resto de x dividido por y z = x%y;
++ Incremento Incrementa x después de usar x++
-- Decremento Decrementa x antes de usar --x
Ejemplos
- i + w; //menos unitario más unitario a*b/c%d //multiplicación, división, módulo a+b a-b //suma y resta binaria a=5/2; //a toma el valor 2, si se considera a entero a=5/2; //a toma el valor 2.5, si a es real
Los operadores de incremento y decremento sirven para incrementar y
decrementar en uno los valores almacenados en una variable.
variable++ //postincremento ++variable //preincremento
variable-– //postdecremento -- variable //predecremento
++a; equivale a a = a +1;
--b; equivale a b = b -1;
Los formatos postfijos se conforman de modo diferente según la
expresión en que se aplica:
b = ++a: equivale a a = a+l; b = a;
b = a++; equivale a b = a; a = a+l;
int i, j, k = 5; k++; //k vale 6, igual efecto que ++k --k; //k vale ahora 5, igual efecto que k-– k = 5; i = 4*k++; //k es ahora 6 e i es 20 k = 5; j = 4 * ++k; //k es ahora 6 e i es 24
B.6.2. Operadores de asignación
El operador de asignación (=) hace que el valor situado a la derecha del
operador se adjudica a la variable situada a su izquierda. La asignación
suele ocurrir como parte de una expresión de asignación y las conversiones
se producen implícitamente.
z = b+5; //asigna (b+5) a variable z
C++ permite asignaciones múltiples en una sola sentencia. Así,
a = b+(c=10);
equivale a:
c=10; a=b+c;
Otros ejemplos de expresiones válidas y no válidas son:
//expresiones legales //expresiones no legales a=5 * (b+a); a+3 = b; double x = y; PI = 3; a=b=6; x++ = y;
C++ proporciona operadores de asignación que combinan operadores
de asignación y otros diferentes, produciendo operadores tales como +=,
/=, –=, *= y % =. C++ soporta otros tipos de operadores de asignación
para manipulación de bits.
GUÍA DE SINTAXIS ANSI/ISO ESTÁNDAR C++ 567
2. Operación lógica OR (||). Si expr1 toma un valor distinto de cero,
la expresión expr1 || expr2 se evaluará a 1, cualquiera que sea el
valor de expr2; en consecuencia, expr2 no se evaluará.
B.6.4. Operadores de manipulación de bits
C++ proporciona operadores de manipulación de bits, así como operadores
de asignación de manipulación de bits.
TABLA B.9. Operadores de manipulación de bits (bitwise)
Operador Significado Ejemplo
& AND bit a bit x & 128
| OR bit a bit j | 64
ˆ XOR bit a bit j ˆ 12
˜ NOT bit a bit ˜j
<< Desplazar a izquierda i << 3
>> Desplazar a derecha j >> 4
TABLA B.10. Operadores de asignación de manipulación de bits
Operador Formato largo Formato reducido
&= x = x & y; x & = y;
|= x = x | y ; x | = y;
ˆ= x = x ^ y; x ˆ = y ;
<<= x = x << y; x << = y; >>= x = x >> y; x >> = y;
Ejemplos
˜x Cambia los bits 1 a 0 y los bits 0 a 1
x & y Operación lógica AND (y) bit a bit de x e y
x | y Operación lógica OR (o) bit a bit de x e y
x << y x se desplaza a la izquierda (en y posiciones)
x >> y x se desplaza a la derecha (en y posiciones)
B.6.5. El operador sizeof
El operador sizeof proporciona el tamaño en bytes de un tipo de dato o
variable. sizeof toma el argumento correspondiente (tipo escalar, array, re-
cord, etc.). La sintaxis del operador es
sizeof (nombre_varíable | tipo_de_dato)
Ejemplos
int m, n[12]; sizeof(m) //proporciona 4, en máquinas de 32 bits sizeof(n) //proporciona 48 sizeof(15) //proporciona 4 tamanyo = sizeof(long) - sizeof(int);
B.6.6. Prioridad y asociatividad de operadores
Cuando se realizan expresiones en las que se mezclan operadores diferentes
es preciso establecer una precedencia (prioridad) de los operadores y la
dirección (o secuencia) de evaluación (orden de evaluación: izquierda-dere-
cha, derecha-izquierda), denominada asociatividad.
La Tabla B.11 muestra la precedencia y asociatividad de operadores.
GUÍA DE SINTAXIS ANSI/ISO ESTÁNDAR C++ 569
TABLA B.11. Precedencia y asociatividad de operadores
Operador Asociatividad Prioridad
::.->++-- Izquierda-Derecha 1
++ -- & (dirección) tipo)! - + + sizeof (tipo) Derecha-Izquierda 2
new delete* (indirección)
.* ->* Izquierda-Derecha 3
* / % Izquierda-Derecha 4
+ - Izquierda-Derecha 5
<< >> Izquierda-Derecha 6
< <= > >= Izquierda-Derecha 7
== != Izquierda-Derecha 8
& Izquierda- Derecha 9
ˆ Izquierda-Derecha 10
| Izquierda-Derecha 11
&& Izquierda-Derecha 12
|| Izquierda-Derecha 13
?: Derecha-Izquierda 14
= += -= *= /= %= >>= <<= &= /= ˆ= Derecha-Izquierda 15
(operador coma) Izquierda-Derecha 16
Ejemplo
a * b/c +d equivale a (a*b) / (c+d)
B.6.7. Sobrecarga de operadores
La mayoría de los operadores de C++ pueden ser sobrecargados o redefini-
dos para trabajar con nuevos tipos de datos. La Tabla B.12 lista los opera-
dores que pueden ser sobrecargados.
Si se desea visualizar el valor del objeto int llamado i, se escribe la
sentencia
cout << i;
El siguiente programa visualiza en pantalla una frase:
#include int main() { cout << “hola, mundo\n”; }
Las salidas en C++ se pueden conectar en cascada, con una facilidad de
escritura mayor que en C.
#include int main() { int i; i = 1099; cout << “El valor de i es” << i << “\n”; }
Otro programa que muestra la conexión en cascada es
#include int main() { int x = 45; double y = 495.125; char c = “y multiplicada por x=”; cout << c << yx << “\n”; }
B.7.2. Entrada
La entrada se maneja por la clase istream. Existe un objeto predefinido is-
tream, llamado cin, que se refiere al dispositivo de entrada estándar (el
teclado). El operador que se utiliza para obtener un valor del teclado es el
operador de extracción >>. Por ejemplo, si i era un objeto int, se escribirá
cin >> i;
que obtiene un número del teclado y lo almacena en la variable i.
570 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
TABLA B.12. Operadores que se pueden sobrecargar
- / % ˆ & | ˜! = < > + = - = * = /= %= ˆ= &= |= << >> >>= <<= == != <= >= && || ++ -- , - >* - > () []
B.7. ENTRADAS Y SALIDAS BÁSICAS
Al contrario que muchos lenguajes, C++ no tiene facilidades incorporadas
para manejar entrada o salida. Estas operaciones se realizan mediante rutinas
de bibliotecas. Las clases que C + + utiliza para entrada y salida se conocen
como flujos. Un flujo es una secuencia de caracteres junto con una colección
de rutinas para insertar caracteres en flujos (a pantalla) y extraer caracteres
de un flujo (de teclado).
B.7.1. Salida
El flujo cout es el flujo de salida estándar que corresponde a stdout en
C. Este flujo se deriva de la clase ostream construida en iostream.
FIGURA B.1. Uso de flujos para salida de caracteres.
Unidad central
cout (^) Pantalla entrada binaria salida de caracteres
C++ permite asignaciones múltiples en una sentencia.
m = n +(p = 5); equivale a p = 5
m = n + p;
B.8.3. Sentencias compuestas
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, expre-
siones, 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 función C++ es siempre una sentencia compuesta.
B.9. SENTENCIAS CONDICIONALES: if
El formato general de una sentencia if es:
if ( expresión) if ( expresión) { sentencia < secuencia de sentencias> }
Si expresión es verdadera (distinta de cero), entonces se ejecuta sen-
tencia o secuencia de sentencias ; en caso contrario se salta la sentencia.
Después que la sentencia if se ha ejecutado, el control pasa a la siguiente sen-
tencia.
Ejemplo 1
if (a < 0) negativos++;
Si la variable a es negativa, se incrementa la variable negativos.
Ejemplo 2
if (numeroDeDias < 0) numeroDeDias = 0;
if ((altura - 5) < 4){ area = 3.14 * radio * radio; volumen = area * altura; }
Ejemplo 3
if (temperatura >= 45) cout << “Estoy en Sonora:Hermosillo, en agosto”; cout << “Estoy en Veracruz” << temperatura << endl;
La frase “Estoy en Sonora:Hermosillo, en agosto” se visualiza
cuando temperatura es mayor o igual que 45. La sentencia siguiente se
ejecuta siempre.
La sentencia if_else tiene el formato siguiente:
- if (expresión) 2. if (expresión)"{ sentencia1; < secuencia de sentencias 1 > else else sentencia2; < secuencia de sentencias 2 >
Si expresión es distinto de cero, la sentencia1 se ejecuta y senten-
cia2 se salta; si expresión es cero, la sentencia1 se salta y sentencia
se ejecuta. Una vez que se ha ejecutado la sentencia if_else, el control
pasa a la siguiente sentencia.
Ejemplo 4
if (Numero == 0) cout << “No se calculará la media”; else media = total / Numero;
Ejemplo 5
if (cantidad > 10){ descuento = 0.2; precio = n * precio(1 - descuento); }
572 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
else { descuento = 0; precio = n * Precio; }
B.9.1. Sentencias if _else anidadas
C++ permite anidar sentencias if_else para crear una sentencia de alternati-
va múltiple:
if ( expresión 1 ) sentencia 1 ; | {sentencía compuesta} else if ( expresión 2 ) sentencia 2 ; | {sentencia compuesta} else if (expresion N) sentencia N; | {sentencia compuesta} [else sentencia N+1; | {sentencía compuesta}]
Ejemplo
if (a > 100) if (b <= 0) SumaP = 1; else SumaN = 1; else Numero = 1;
B.9.2. Sentencias de alternativa múltiple: switch
La sentencia switch ofrece una forma de realizar decisiones de alternativas
múltiples. 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 expresión cuyo valor sea entero.
Este valor puede ser una constante, una variable, una llamada a función o
una expresión. El valor de constante ha de ser una constante. Al ejecutar
la sentencia se evalúa expresión, y si su valor coincide con una cons-
tante , se ejecutan las sentencias a continuación de ella; en caso contrario se
ejecutan las sentencias a continuación 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'; }
B.10. BUCLES: SENTENCIAS REPETITIVAS
Los bucles sirven para realizar tareas repetitivas. En C++ existen tres dife-
rentes tipos de sentencias repetitivas:
B.10.1. Sentencia while
La sentencia while es un bucle condicional que se repite mientras la con-
dición es verdadera. El bucle while nunca puede iterar si la condición
comprobada es inicialmente falsa. La sintaxis de la sentencia while es:
GUÍA DE SINTAXIS ANSI/ISO ESTÁNDAR C++ 573
cout << “Entrar”; cin >> n; suma += n; }
B. 10.4. Sentencias 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 también se utiliza para salir de la sentencia
switch.
La sentencia continue termina la iteración que se está realizando y
comenzará de nuevo la siguiente iteración:
for (i = 0; i < 100; ++i) cin >> x; if (x < 0.0) continue;
B.10.5. Sentencia nula
La sentencia nula se representa por un punto y coma, y no hace ninguna
acción.
Advertencia:
- Una sentencia break puede ocurrir únicamente en el cuerpo de una
sentencia for, while, do o switch.
- Una sentencia continue sólo puede ocurrir dentro del cuerpo de una
sentencia for, while o do.
char cad[80]=“Cazorla”; int i;
for(i=0; cad[i] !='\0'; i++) ;
B.10.6. Sentencia return
La sentencia return detiene la ejecución de la función actual y devuelve el
control a la función llamada. Su sintaxis es:
return expresion ;
donde el valor de expresión se devuelve como el valor de la función.
B.11. PUNTEROS (APUNTADORES)^3
Un puntero o apuntador es una referencia indirecta a un objeto de un tipo
específicado. En esencia, un puntero contiene la posición de memoria de un
tipo dado.
B.11.1. Declaración de punteros
Los punteros se declaran utilizando el operador unitario. En las sentencias
siguientes se declaran dos variables: n es un entero, y p es un puntero a un
entero.
int n; //n es un tipo de dato entero int *p; //p es un puntero a un entero
Una vez declarado un puntero, se puede fijar la dirección o posición de
memoria del tipo al que apunta.
p = &n; //p se fija a la dirección de n
Un puntero se declara escribiendo:
NombreTipo *NombreVariable
GUÍA DE SINTAXIS ANSI/ISO ESTÁNDAR C++ 575
(^3) El término puntero es el más utilizado en España, mientras que en Latinoamérica se suele utilizar apuntador.
p
Este elemento se puede llamar por: Este elemento se puede llamar por:
a[0], *p o bien p[0] a[6], *(p+6) o bien p[6]
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.
int *p, q, n; //dos punteros a int, y un int n = -25; //n se fija a - p = 105; //p a 105 q = n +p; //q a 80
C++ trata los punteros a tipos diferentes como tipos diferentes:
int *ip; double *dp;
Los punteros ip y dp son incompatibles, de modo que es un error escribir
dp = ip; //Error, no se pueden asignar punteros a tipos //diferentes
Se pueden, sin embargo, realizar asignaciones entre contenidos, ya que
se realizaría una conversión explícita de tipos.
*dp = *ip;
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 válidas. El conocimiento nos permite comprobar si un
puntero p es el puntero NULL evaluando la expresión (p==0). Los punteros
NULL se utilizan sólo como señales de que ha sucedido algo. En otras pala-
bras, si p es un puntero NULL, es correcto referenciar *p.
B.11.2. Punteros a arrays
A los arrays se accede a través de los índices:
int lista[5]; lista[3] = 5;
A los arrays también se puede acceder a través de punteros:
int lista[5]; //array de 5 elementos int *ptr; //puntero a entero ptr = lista; //fija puntero al primer elemento del array ptr += 2; //suma 3 a ptr; ptr apunta al 4° elemento *ptr = 5; //establece el 4° elemento a 5
double a[10]; double *p = a; //p y a se refieren al mismo array
El nombre de un array se puede utilizar también como si fuera un punte-
ro al primer elemento del array.
576 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
Si nombre apunta al primer elemento del array, entonces nombre + 1
apunta al segundo elemento. El contenido de lo que se almacena en esa posi-
ción se obtiene por la expresión
*(nombre+1)
B.11.3. Punteros a estructuras
Los punteros a estructuras son similares y funcionan de igual forma que los
punteros a cualquier otro tipo de dato.
struct familia { char *marido; char *esposa; char *hijo; };
familia mackoy; //mackoy estructura de tipo familia familia *p; //p, un puntero a familia p = &mackoy; //p, contiene dirección de mackoy
Aunque las funciones no pueden modificar sus argumentos, si un array
se utiliza como un argumento de una función, la función puede modifi-
car el contenido del array.
punteros son: suma, resta y comparación. Así, si las sentencias siguientes se
ejecutan en secuencia:
char *p; //p contiene la dirección de un carácter char a[10]; // array de diez caracteres p = &a[0]; //p apunta al primer elemento del array p++; //p apunta al segundo elemento del array p++; //p apunta al tercer elemento del array p--; //p apunta al segundo elemento del array
Un ejemplo de comparación de punteros es el siguiente programa:
#include main (void) { int *ptr1, ptr2; int a[2] = {10,10}; ptr1 =a; cout << “ptr1 es” << “ptr1 << “ptr1 es” << ptr1 << endl; ptr2 = ptr1 + 1; cout << “ptr2 es” << ptr2 << “Ptr2 es” << *ptr2 << endl;
//comparar dos punteros if (ptr1 == ptr2) cout << “ptr1 no es igual a ptr2 \n”;
if (*ptr1 == *ptr2) cout << ptr1 es igual a *ptr2 \n”; else cout << ptr1 no es igual a *ptr2 \n”; }
B. 12. LOS OPERADORES new Y delete
C++ define un método para realizar asignación dinámica de memoria, dife-
rente del utilizado en C, mediante los operadores new y delete.
El operador new sustituye a la función malloc tradicional en C, y el
operador delete sustituye a la función free tradicional también en C; new
asigna memoria y devuelve un puntero al objeto últimamente creado. Su
sintaxis es:
new NombreTipo
y un ejemplo de su aplicación es:
int *ptr1; double *ptr2;
ptr1 = new int; //memoria asignada para el objeto ptr ptr2 = new double; //memoria ampliada para el objeto ptr *ptr1= 5; *ptr2= 6.55;
Dado que new devuelve un puntero, se puede utilizar ese puntero para
inicializar el puntero en una sola definición, tal como:
int* p = new int;
Si new no puede ocupar la cantidad de memoria solicitada, devuelve un
valor NULL. El operador delete libera la memoria asignada mediante new.
delete ptr1;
Un pequeño programa que muestra el uso combinado de new y delete es,
#include void main (void) { char *c;
c = new char[512]; cin >> c; cout << c << endl;
delete c; }
Los operadores new y delete se pueden utilizar para asignar memoria
a arrays, clases y otro tipo de datos.
int * i; i = new int[2][35]; //crear el array //asignar el array ... delete i; //destruir el array
Sintaxis de new y delete:
new nombre_tipo new int new char[100] new nombre_tipo inicializador new int(99) new char(‘C’) new nombre_tipo new (char*) delete expresión delete p delete[] expresión delete[]
578 PROGRAMACIÓN EN C++. ALGORITMOS, ESTRUCTURAS Y OBJETOS
B. 13. ARRAYS
Un array^4 ( matriz, tabla ) es una colección de elementos dados del mismo
tipo que se identifican por medio de un índice. Los elementos comienzan
con el índice 0.
Declaración de arrays
Una declaración de un array tiene el siguiente formato:
nombreTipo nombreVariable[n]
Algunos ejemplos de arrays unidimensionales:
int ListaNum[2]; //array de dos enteros char ListaNombres[10] ; //array de 10 caracteres
Arrays multidimensionales son:
nombretipo nombreVariable[nl] [n2] ... [nx];
El siguiente ejemplo declara un array de enteros 4 × 10 × 3
int multidim[4][10][3];
El ejemplo tabla declara un array de 2 × 3 elementos.
int tabla[2][3]; //array de enteros de 2x3 = 6 elementos
B.13.1. Definición de arrays
Los arrays se inicializan con este formato:
int a[31 = {5, 10, 15}; char cad[5] = {a', 'b', 'c', 'd', 'e'}; int tabla[2][3] = {{1,2,3}{3,4,5}};
Las tres siguientes definiciones son equivalentes:
char saludo[5]= “hola”; char saludo[] = “hola”; char saludo[5] = {'h', 'o', 'l', 'a', '\o'};
B.14. ENUMERACIONES, ESTRUCTURAS Y UNIONES
En C++, un nombre de una enumeración, estructura o unión es un nombre
de un tipo. Por consiguiente, la palabra reservada struct, union o enum
no son necesarias cuando se declara una variable.
El tipo de dato enumerado designa un grupo de constantes enteros con
nombres. La palabra reservada enum se utiliza para declarar un tipo de dato
enumerado o enumeración. La sintaxis es:
enum nombre { lista_simbolos };
donde nombre es el nombre de la variable declarada enumerada;
lista-símbolos es una lista de tipos enumerados, a los que se asigna valo-
res cuando se declara la variable enumerada y puede tener un valor de ini-
cialización. Se puede utilizar el nombre de una enumeración para declarar
una variable de ese tipo (variable de enumeración).
nombre var;
Considérese la siguiente sentencia:
enum color {Rojo, Azul, Verde, Amarillo};
Una variable de tipo enumeración color es:
color pantalla = Rojo; //Estilo C++
Una estructura es un tipo de dato compuesto que contiene una colec-
ción de elementos de tipos de datos diferentes combinados en una única
construcción del lenguaje. Cada elemento de la colección se llama miembro
y puede ser una variable de un tipo de dato diferente. Una estructura repre-
senta un nuevo tipo de dato en C++.
1. Los arrays se pueden pasar como argumentos a funciones.
2. Las funciones no pueden devolver arrays.
3. No está permitida la asignación entre arrays. Para asignar un array a
otro se debe escribir el código para realizar las asignaciones elemen-
to a elemento.
GUÍA DE SINTAXIS ANSI/ISO ESTÁNDAR C++ 579
(^4) En Latinoamérica, este término se traduce al español por la palabra arreglo.
Esta lectura del teclado lee una cadena hasta que se encuentra el primer
carácter blanco. Así, cuando se lee “Sierra Mágina. Jaén”, en cad sólo
se almacena Sierra. Para resolver el problema se utiliza la función gets
(), que lee una cadena completa leída del teclado. El programa anterior se
escribe así para leer toda la cadena introducida:
#include #include
main() { char cad[80];
cout << “Introduzca una cadena:”; gets(cad); cout << “Su cadena es:”; cout << cad;
return 0; }
B.16. FUNCIONES
Una función es una colección de declaraciones y sentencias que realizan una
tarea única. Cada función tiene cuatro componentes: 1) su nombre; 2) el tipo
de valor que devuelve cuando termina su tarea; 3) la información que toma
al realizar su tarea, y 5) la sentencia o sentencias que realizan su tarea. Cada
programa C++ tiene al menos una función: la función main.
B.16.1. Declaración de funciones
En C + + se debe declarar una función antes de utilizarla. La declaración de
la función indica al compilador el tipo de valor que devuelve la función y el
número y tipo de argumentos que toma. La declaración en C++ se denomi-
na prototipo:
tipoNombreFuncion (lista argumentos);
Ejemplos válidos son:
double Media(double x, double y); void Print(char* formato, ...); extern max(const int*, int); char LeerCaracter();
B.16.2. Definición de funciones
La definición de una función es el cuerpo de la función, que se ha declara-
do con anterioridad.
double Media(double x, double y) //Devuelve la media de x e y { return (x+y)/2.0; }
char LeerCaracter(); //Devuelve un carácter de la entrada estándar { char c; cin >> c; return c; }
B.16.3. Argumentos por omisión
Los parámetros formales de una función pueden tomar valores por omisión,
o argumentos cuyos valores se inicializan en la lista de argumentos forma-
les de la función.
int Potencia (int n, int k=2);
Potencia(256); //256 elevado al cuadrado
Los parámetros por omisión no necesitan especificarse cuando se llama
a la función. Los parámetros con valores por omisión deben estar al final de
la lista de parámetros:
void func1 (int i=3, int j); //ilegal 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);
Llamadas a la función ImprimirValores son:
ImprimirValores (n,a); ImprimirValores (n); //equivalente a ImprimirValores (n, 0.0)
Otras declaraciones y llamadas a funciones son:
GUÍA DE SINTAXIS ANSI/ISO ESTÁNDAR C++ 581
double f1(int n, int m, int p=0); //legal double f2(int n, int m=1, int p=0); //legal double f3(int n=2, int m=1, int p=0); //legal double f4(int n, int m=1, int p); //ilegal double f5(int n=2, int m, int p=0); //ilegal
B.16.4. Funciones en línea (inline)
Si una declaración de función está precedida por la palabra reservada inli-
ne, el compilador sustituye cada llamada a la función con el código que
implementa la función.
inline int Max(int a, int b) { if (a>b) return a; return b; }
main () { int x = 5, y = 4; int z = Max(x,y); }
Los parámetros con valores por omisión deben entrar al final de la lista
de parámetros: las funciones f1, f2 y f3 son válidas, mientras que las
funciones f4 y f5 no son válidas.
Las funciones en línea (inline) evitan los tiempos suplementarios de las
llamadas múltiples a funciones. Las funciones declaradas en línea deben ser
simples, con sólo unas pocas sentencias de programa; sólo se pueden llamar
un número limitado de veces y no son recursivas.
inline int abs(int i); inline int min(int v1, int v2); int mcd(int v1, int v2);
Las funciones en línea deben ser definidas antes de ser llamadas:
#include int incrementar(int i);
inline incrementar(int i) { i++; return; }
main (void) { int i = 0; while (i < 5) { i = incrementar(i); cout << “i es: ”<< i << endl; } }
B.16.5. Sobrecarga de funciones
En C++, dos o más funciones distintas pueden tener el mismo nombre. Esta
propiedad se denomina sobrecarga. Un ejemplo es el siguiente:
int max (int, int); double max (double, double);
o bien este otro:
void sumar (char i); void sumar (float j);
Las funciones sobrecargadas se diferencian en el número y tipo de argu-
mentos, o en el tipo que devuelven las funciones, y sus cuerpos son dife-
rentes en cada una de ellas.
#include
