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, fundamentalmente orientada a
objetos. ANSI C ya adoptó numerosas características de C++, por lo que la migració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 Manual (ARM) de Stroustrup y Ellis, así como las últimas propuestas
incorporadas al nuevo borrador de C++ ANSI, que se incluyen en las versiones 3 (actual)
y 4 (futura de AT&T C++).
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, identificadores, constantes, constantes de
cadena, operadores y signos de puntuación.
Caracteres
Los caracteres
que se pueden utilizar para construir elementos del lenguaje (componentes
léxicos o tokens) son:
abcdefghi
jklmnopqrstuvwxyz
ABCDEFCHIJKLMNOPQRSTUVWXYZ
0123456789
caracteres
espacio (blancos
y tabulaciones)
Identificadores
Los identificadores
(nombres de variables, constantes,...) deben comenzar con una letra del
alfabeto (mayúscula o minúscula) o con un carácter subrayado, y pueden tener
uno o más caracteres. Los caracteres segundo y posteriores pueden ser: letras,
dígitos o un subrayado, no permitiéndose caracteres no alfanuméricos ni
espacios.
tescprueba // legal
Xl23 // legal
multi_palabra // legal
var25 // legal
l5var // no legal
C++ es sensible
a las mayúsculas.
Paga_mes es un identificador
distinto a paga_mes
Una buena práctica de
programación aconseja utilizar identificadores significativos que ayudan a
documentar un programa.
nombre apellidos salario
precio_neto
Palabras reservadas
Las palabras
reservadas o claves no se deben utilizar como identificadores, debido a su
significado estricto en C++; tampoco se deben
redefinir. La Tabla B. 1 enumera las palabras reservadas de C++ según el
ARM(Siglas del libro de BJARNE STROUSTRUP en el que se definen las
reglas de sintaxis del lenguaje C++ estándar).
Palabras reservadas de C++
*Estas palabras no
existen en ANSI C.
Los diferentes
compiladores comerciales de C++ pueden incluir, además, nuevas palabras
reservadas. Estos son los casos de Borland, Microsoft y Sysmantec.
Palabras
reservadas de Turbo/Borland C++
Palabras
reservadas de Microsoft Visual C/C++ 1.5/2.0
El comité ANSI
ha añadido nuevas palabras reservadas.
Nuevas
palabras reservadas de ANSI C++
TIPOS DE DATOS
Los tipos de
datos simples en C++ se dividen en dos grandes grupos: integrales (datos
enteros) y de coma flotante (datos reales). La Tabla muestra los diferentes
tipos de datos en C++,
Tipos
de datos simples en C++
Verificación de tipos
La verificación
o comprobación de tipos en C++ es más rígida (estricta) que en C. Algunas
consideraciones a tener en cuenta son:
Usar funciones
declaradas. Esta
acción es ilegal en C++, y está permitida en C:
int main()
{
//...
printf(x) //C int printf(x)
//C++ es ilegal, ya que
printf no esta declarada
return 0;
}
• Fallo al
devolver un valor de una función. Una función en C++ declarada con un tipo
determinado de retomo, ha de devolver un valor de ese tipo. En C, está
permitido no seguir la regla.
• Asignación de
punteros void.
La asignación de un tipo void* a un puntero de otro tipo se debe hacer con una
conversación explícita en C++. En C, se realiza implícitamente.
• Inicialización
de constantes de cadena. En C++ se debe proporcionar un espacio para el
carácter de terminación nulo cuando se inicializan constantes de cadena. En C,
se permite la ausencia de ese carácter
int main()
{
//......
char car[7] = “Cazorla“; //
legal en C
//error en C++
//......
return 0;
}
Una solución al
problema que funciona tanto en C como en C++ es: char car [] ="Cazorla";
CONSTANTES
C++ contiene
constantes para cada tipo de dato simple (integer, char,...). Las constantes
pueden tener dos sufijos, u, l y f. Que indican tipos unsigned, long y float,
respectivamente. Así mismo, se pueden añadir los prefijos o y ox, que
representan constantes octales y hexadecimales.
456 0456 0x476 // constante
enteras : decima1, octal , hexadecimal
1231 123ul // constante enteras :long, unsigned, long
´B´ ´b´ ´4´ // constante de
tipo char
3.1415f // constante reales
de diferente posición
“cadena de caracteres” //
Constante de cadena
Las cadenas de
caracteres se encierran entre comillas, y las constantes de un solo carácter se
encierran entre comillas simples.
” ” // cadena vacía ‘\0’
Declaración de
constantes
En C++, los
identificadores de variables/constantes se pueden declarar constantes, significando
que su valor no se puede modificar. Esta declaración se realiza con la palabra
reservada const.
contar double PI= 3.11416;
const char BLANCO = ´ ´;
const double PI_EG = -I;
const double DOBLE_I = 2 * PI ;
El modificador
de tipos const se utiliza en C++, también para proporcionar 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
por referencia sean modificados:
void copy (const char *
fuente, char * destino):
DECLARACIÓN DE
VARIABLES
En ANSI C, 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 ajustes o
inserciones necesarios. Todas las declaraciones deben hacerse antes de que se
ejecute cualquier sentencia. Así, la declaración típica en C++, NombreTipo Nombrevariablel,
Nombrevariable2;
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,
anio=1995;
doble 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 <stdio.h>
int main ()
{
int i ;
for ( i= 0; i<100; ++i)
printf ( “%d\n” , i);
double j;
for ( j= 1.7547; j<25.4675; j+= .001)
printf ( “%lf\n” , j);
}
El programa
anterior se podría reescribir, 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 ( int j= 1.7547; j<25.4675; j+= .001)
cout << j <<;
}
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.
Operadores
aritméticos
C++ proporciona
diferentes operadores que relacionan operaciones aritméticas.
Operadores
aritméticos en C++
Operadores de
asignación
El operador de
asignación (=) hace que el valor situado a la derecha del operador se adjudique
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; //asigne (b + 5)
a variable z
C++ permite
asignaciones múltiples en una sola sentencia. Así:
a = b + (c=l0); 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;
doble x = y; PI = 3;
// siendo PI una constante
a = b = c; 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 de operadores de asignación para manipulación de bits.
Operadores
aritméticos de asignación
BUCLES:
SENTENCIAS REPETITIVAS
Los bucles sirven para
realizar tareas repetitivas. En C++, existen tres diferentes tipos de
sentencias repetitivas:
• while
• do
• for
Sentencia while
La sentencia while es
un bucle condicional que se repite mientras la condición es verdadera. El bucle
while nunca puede iterar si la condición comprobada es inicialmente falsa. La
sintaxis de la sentencia while es:
while (expresión)
sentencia;
o bien:
while (expresión) {
< secuencia de
sentencias >
}Página 16 de 28
Ejemplo:
int n, suma = 0;
int i = 1;
while ( i <= 100 )
{
cout << “Entrar”;
cin >> n;
suma += n;
i++;
}
cout << “La media
es” << double(suma) / 100.0;
Sentencia do
La sentencia do actúa
como la sentencia while. La única diferencia real es que la evaluación y la
prueba de salida del bucle se hace después que el cuerpo del bucle se ha
ejecutado, en lugar de antes. El formato es:
do {
sentencias
}while (expresión);
sentencia siguiente
Se ejecuta sentencia y
a continuación se evalúa expresión y, si es verdadero (distinto de cero), el
control se pasa de nuevo al principio de la sentencia do y el proceso se
repite, hasta que expresión es falso(cero) y el control pasa a la sentencia
siguiente.
La sentencia for
Una sentencia for
ejecuta la iteración de un bucle un número determinado de veces. for tiene tres
componentes: expresion1, inicializa las variables de control del bucle;
expresion2, es la condición que
determina si el bucle realiza otra iteración; la última parte del bucle for es
la cláusula que incrementa o decrementa las variables de control del bucle. El
formato general de for es:
for (expresionl;
expresion2; expresion3)
sentencia; <secuencia
de sentencias>;
expresionl se utiliza
para inicializar la variable de control de bucle; a continuación expresion2 se
evalúa, si es verdadera (distinta de
cero), se ejecuta la
sentencia y se evalúa expresion3 y el control pasa de nuevo al principio del
bucle. La iteración continúa hasta que
expresion2 es falsa
(cero), en cuyo momento el control pasa a la sentencia siguiente al bucle.
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 flor 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;
}
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.
Sentencia nula
La sentencia nula se
representa por un punto y coma, y no hace ninguna acción.
char cad[80]=”Cazorla”;
int i;
for (i = 0; cad[i] != ‘\0’; i++);
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 expresión;
donde el valor de
expresión se devuelve como el valor de la función.
No hay comentarios:
Publicar un comentario