Home » C++ » Sentencias en C++

Sentencias en C++

Sentencias

Sentencias declarativas:

Son las sentencias que sirven para definir componentes del programa: variables, tipos, funciones, etc. El compilador las procesa pero no producen código ejecutable. Por ejemplo:

char bandera[50] ;
int orden(int);

Sentencias ejecutables:

Son las que el compilador convierte en código ejecutable. Son acciones de programa: asignaciones, operaciones aritméticas, bifurcaciones, llamadas a funciones, etc. Por ejemplo:

a = b;
c = a / 200;

Bucles

C++ posee tres sentencias para realizar iteraciones o procesos repetitivos: For, While, Do-While.

Sentencia for

La sentencia for tiene la siguiente sintaxis:
for (expresión de inicialización; expresión de evaluación; expresión de actualización)
cuerpo del bucle

  • El cuerpo del bucle se ejecuta mientras la expresión de evaluación se mantenga True. El cuepro del bucle está compuesto por una sentencia o por un bloque de sentencias encerrado por corchetes.
  • Expresión de inicialización, es un proceso que se hace una vez al principio de la ejecución.
  • Expresión de evaluación: normalmente es una expresión relacional.
  • Expresión de actualización: es un proceso que se realiza al final de cada bucle. Normalmente, aquí se incrementa o decrementa el valor que luego se comprueba.

Por ejemplo:

for (j= 0, k =7; j + k < 10; j++, k++)
cout << j << «, « << k << ‘\n’;

La ejecución daría este resultado:
0, 7
1, 8

Sentencia While

El bucle conducido por una sentencia While es similar a una sentencia For simplificada: no tiene expresión de inicialización ni expresión de actualización. Sólo hay una expresión de evaluación. La sintaxis es la siguiente:
while ( expresión de evaluación)
cuerpo del bucle
Cuando se ejecuta la sentencia While, primero, se evalúa la expresión, si es True se ejecutan las sentencias codificadas en el cuerpo del bucle, en caso contrario, no se toman en cuenta ninguna de las sentencias del cuerpo del bucle y se continúa en secuencia.
El cuerpo del bucle se ejecuta mientras la expresión de evaluación se mantenga True. El cuerpo del bucle, igual que en la sentencia for, está compuesto por una sentencia o por un bloque de sentencias encerrado por corchetes. Al finalizar la ejecución de la/s sentencia/s del cuerpo del bucle se repite la evaluación de la expresión. El proceso se repite hasta que la evaluación sea False.

Sentencia Do-While

El bucle conducido por una sentencia Do-While es similar a una sentencia While con una diferencia fundamental: la evaluación de la expresión se hace luego de haber ejecutado el cuerpo del bucle. O sea, el bucle se ejecuta siempre al menos una vez. Luego funciona igual que la sentencia While. La sintaxis es la siguiente:
Do
cuerpo del bucle

while ( expresión de evaluación);

Sentencias condicionales y de bifurcación

Las sentencias condicionales y de bifurcación son las siguientes: if, if else, switch, break y continue.

Sentencia If

La sentencia If se utiliza cuando se quiere tomar alguna decisión acerca del camino a seguir en la seciencia del programa. La sentencia If permite decidir si se ejecuta u omite una sentencia o bloque de sentencias. La sintaxis es similar a la de la sentencia While:
if ( expresión de evaluación)
cuerpo;
Se evalúa la expresión, si es True se ejecuta la sentencia o bloque de sentencias (cuerpo) y si es False se salta la sentencia o bloque de sentencias que hay a continuación.
Éste es un ejemplo:

if (a > 5)
a++; // si a es mayor a cinco se incrementa en uno
k++; // esta sentencia se ejecuta siempre, independientemente
// del resultado de la sentencia if

Sentencia If-else

La sentencia If-else permite definir dos sentencias o bloques de sentencias que se ejecutarán de manera excluyente según sea el resultado de la evaluación de la expresión. Permite expresar lógicamente esta situación: si se cumple la condición hágase esto, en caso contrario, hágase aquello.La sintaxis es la siguiente:
if ( expresión de evaluación)
cuerpo1;
else
cuerpos2;
Éste es un ejemplo:

if (a > 5)
// se define una sentencia única
a++; // si a es mayor a cinco se incrementa en uno
else
{
// Se define un bloque de sentencias
a—; // si a no es mayor a cinco se le resta uno
cout <<«Ha sido False\n»;
}
k++; // esta sentencia se ejecuta siempre, independientemente
// del resultado de la sentencia if

Sentencia switch

La sentencia switch es una alternativa a if-else. Tiene esta sintaxis:

switch (expresión)
{
case valor1:
sentencia1;
sentencia2;
case valor2:


default:
sentencian1;
sentencian2;
}

Si la expresión evalúa valor1 se ejecutan las sentencias que hay a partir de ese bloque case y hasta el final (o sea, hasta sentencian2) o hasta encontrar la primera sentencia break. Si en cambio evalúa valor2 se ejecutarán las sentencias que hay a partir de esa sentencia y hasta el final. Esto es algo muy particular de la sentencia switch y es lo que la diferencia de una sentencia SELECT-CASE de otros lenguajes. La sentencia switch puede funcionar igual que la lógica SELECT-CASE pero para eso requiere utilizar sentencias break. Finalmente, si la expresión no coincidió con ningún valor case se procesará el bloque Default.

switch (expresión)
{
case valor1:
sentencia1;
sentencia2;
break; // pasa la ejecución a la primera sentencia después
// del corchete
case valor2:

break; // pasa la ejecución a la primera sentencia después
// del corchete

default:
sentencian1;
sentencian2;
break; // sentencia innecesaria
}

Éste es un ejemplo válido de la sentencia switch-case:

switch (color)
{
case rojo: cout << «El color es rojo.\n»;
break;
case verde: cout << «El color es verde.\n»;
break;
case azul:
case negro:
cout << «El color es negro o azul.\n»;
break;
default: cout << «Color no previsto.\n»;
}

Sentencia break

La sentencia break provoca la salida de un bucle o de una sentencia switch, no de todos los que pueda haber. Si hay anidamientos pueden hacer falta más sentencias break.

for (int i = 3; i < 20; i++)
{

if (i = 7) break; // si pasa por esta sentencia con I = 7,
// saldrá del bucle for

};

Pero puede hacer falta más de una sentencia break:


do {
do {

if (I = 7) break; // sale sólo de este bucle do
} while(…);
// la sentencia break provoca el salto hasta aquí
} while (…);

Sentencia continue

La sentencia continue se usa dentro de bucles (for, while, do-while) y provoca la bifurcación a la sentencia de evaluación del bucle. Mientras la sentencia break provoca la salida del bucle, la sentencia continue provoca una nueva iteración cuando la evaluación es True. En el caso de un bucle de tipo for, la sentencia continue salta el resto del bucle pero no deja de ejecutar la expresión de actualización antes de realizar la evaluación.
Éstos son dos ejemplos del uso de la sentencia continue:

do {

if (I = 7) continue; // bifurca a la sentencia while

} while(…); // la sentencia continue bifurca a esta sentencia

while (…) // la sentencia continue provoca la evaluación

if (I = 7) continue; // bifurca a la sentencia while

} ;
sentencia…

Bloques de sentencias:

Una o más sentencias puede definir un bloque de sentencias mediante su encierro con llaves. Por ejemplo:

{
a = 1;
b = a + b;
};

Incluso un bloque puede estar definido sin ninguna sentencia:

{}

Reserva de memoria

Las variables definidas de la manera que se ha visto hasta ahora ocupan una posición estática en memoria que se resuelve en tiempo de compilación. En C se utiliza la función malloc() para reservar memoria de manera dinámica. Aunque en C++ también se puede segior aplicando esta función, C++ tiene un operador específico para la reserva dinámica de memoria durante la ejecución, el operador new. El operador new encuentra un bloque de memoria de la longitud necesaria y devuelve la dirección de ese bloque. La sintaxis de este operador es la siguiente:

           nombreTipo      nombreApuntador = new nombreTipo;

int *pint = new int; // define un espacio para un entero

Pero también se puede definir un tipo int de la manera acostumbrada:

int varint;
int *pvarint = &varint;

¿Cuál es la diferencia entre el primer y el segundo método? El primer método reserva la memoria de manera dinámica durante la ejecución, en cambio, en el segundo método la memoria se reserva durante la compilación. Conceptualmente también hay otra diferencia: el operador new reserva memoria para un objeto de dato, lo que representa una idea más amplia que el término variable.
Como el operador new se resuelve en tiempo de ejecución, podría suceder que no se dispone de la memoria solicitada. En tal caso, C++ asigna el apuntador null para indicar esta situación. Si se comprueba esta situación después del requerimiento de memoria, el programa puede tomar una decisión para resolver el problema, o en el peor de los casos, finalizar.
La memoria reservada con el operador new se puede liberar con el operador delete.

delete pint; // libera la memoria apuntada por pint

El operador delete se puede usar para liberar memoria reservada únicamente con el operador new. No obstante, no es obligatorio utilizar el mismo nombre de apuntador que se usó en la reserva de la memoria: lo importante es la dirección apuntada.
Normalmente, el operador new se suele utilizar con bloques de memoria de mayor tamaño. Por ejemplo, la declaración de una simple variable entera se puede hacer de manera estática (vinculación estática) y no representa ningún problema, así como tampoco no representa niguna gran ventaja hacerlo con el operador new. Donde cobra realmente importancia el operador new es cuando se declaran matrices, estructuras o cadenas. Especialmente cuando se trata de variables cuya definición está supeditada a la lógica del proceso. ¿Para qué vamos a definir una matriz de manera estática (en tiempo de compilación) cuando sólo se usa en algunas ejecuciones del programa? Otra gran ventaja de la reserva dinámica de la memoria es que se pueden dimensionar las matrices según las necesidades y no de una manera rígida y predeterminada.
También se puede reservar memoria para una matriz:

int *pint = new int [20]; // reserva memoria para 20 enteros

En este caso, la liberación de memoria debe utilizar corchetes:

delete [] pint;

izq sup der

Deja un comentario