Componentes de C++
Directivas de los componentes del C++:
El lenguaje de programación C++ está
caracterizado por ser de uso general, con una sintaxis sumamente compacta y de
alta portabilidad. Es común leer que se caracteriza como un lenguaje de “alto
nivel”, maneja los elementos básicos presentes en todas las computadoras:
caracteres, números y direcciones. Esta particularidad, junto con el hecho de
no poseer operaciones de entrada salida, manejo de arreglo de caracteres, de
asignación de memoria, puede al principio parecer un grave defecto; sin embargo
el hecho de que estas operaciones se realicen por medio de llamadas a Funciones
contenidas en Librerías externas al lenguaje en sí, es el que confiere al mismo
su alto grado de portabilidad, independizandolo del “Hardware” sobre el cual corren
los programas
Un programa en C++ está definido por
funciones (grupo de instrucciones que pueden o no hacer algún cálculo), donde
la función principal debe ser llamada main.
La composición general de un programa en
C++ es:
*Directivas de preprocesamiento.
*Declaración globales.
*Función main.
*Funciones definidas por el usuario.
*Comentarios para entender el funcionamiento
del programas.
Declarariones Globales:
Una característica de C++, es la necesidad
de declarar las variables que se usarán en un programa. Esto resulta chocante
para los que se aproximan al C++ desde otros lenguajes de programación en los
que las variables de crean automáticamente la primera vez que se usan. Se
trata, es cierto, de una característica de bajo nivel, más cercana al
ensamblador que a lenguajes de alto nivel, pero en realidad una característica
muy importante y útil de C++, ya que ayuda a conseguir códigos más compactos y
eficaces, y contribuye a facilitar la depuración y la detección y corrección de
errores y a mantener un estilo de programación elegante.
Uno de los errores más comunes en lenguajes
en los que las variables se crean de forma automática se produce al cometer
errores ortográficos. Por ejemplo, en un programa usamos una variable
llamada prueba, y en un punto determinado le asignamos un nuevo
valor, pero nos equivocamos y escribimos prubea. El compilador o
interprete no detecta el error, simplemente crea una nueva variable, y continúa
como si todo estuviese bien.
En C++ esto no puede pasar, ya que antes de
usar cualquier variable es necesario declararla, y si por error usamos una variable
que no ha sido declarada, se producirá un error de compilación.
Cómo se
declaran las variables
Ya hemos visto la mecánica de la
declaración de variables, al mostrar la sintaxis de cada tipo en el capítulo 2.
El sistema es siempre el mismo, primero se
especifica el tipo y a continuación una lista de variables y finalmente un
punto y coma.
La declaración de variables es uno de los
tipos de sentencia de C++. La prueba más clara de esto es que la declaración
terminará con un ";". Sintaxis:
<tipo> <lista de
variables>;
También
es posible inicializar las variables dentro de la misma declaración. Por
ejemplo:
int a = 1234;
bool seguir = true, encontrado;
Dependiendo
de dónde se declaren las variables, podrán o no ser accesibles desde distintas
partes del programa. Es decir, su ámbito de acceso y temporal dependerá del
lugar en que se declaren. Las variables declaradas dentro de un bucle, serán
accesibles sólo desde el propio bucle, esto es, tendrán un ámbito local para el
bucle. Esto es porque las variables se crean al inciar el bucle y se destruyen
cuando termina. Evidentemente, una variable que ha sido destruida no puede ser
accedida, por lo tanto, el ámbito de acceso está limitado por el ámbito
temporal.
Nota: En compiladores de C++ antiguos, (y en algunos
modernos y mal implementados), no existe este ámbito, que sin
embargo está descrito en la norma ANSI.
En estos compiladores, las variables declaradas dentro de un bucle tienen el mismo ámbito temporal y de acceso que las variables locales. Es decir, existen y son accesibles desde el punto en que se declaren hasta el final de la función.
Si usamos uno de esos compiladores no será posible, por ejemplo, usar varios bucles con declaraciones de variables locales de bucle con el mismo nombre.
for(int i=0; i < 100; i++) HacerAlgo(i);
for(int i=0; i > -100; i--) DeshacerAlgo(i);
Este código daría un error al intentar redefinir la variable local i.
En estos compiladores, las variables declaradas dentro de un bucle tienen el mismo ámbito temporal y de acceso que las variables locales. Es decir, existen y son accesibles desde el punto en que se declaren hasta el final de la función.
Si usamos uno de esos compiladores no será posible, por ejemplo, usar varios bucles con declaraciones de variables locales de bucle con el mismo nombre.
for(int i=0; i < 100; i++) HacerAlgo(i);
for(int i=0; i > -100; i--) DeshacerAlgo(i);
Este código daría un error al intentar redefinir la variable local i.
Las
variables declaradas dentro de una función, y recuerda que main también
es una función, sólo serán accesibles para esa función, desde el punto en que
se declaran hasta el final. Esas variables son variables locales o de ámbito
local de esa función. Al igual que ocurre con las variables locales de bucle,
en las de función, las variables se crean al inciar la función y se destruyen
al terminar. Las variables declaradas fuera de las funciones, serán accesibles
desde todas las funciones definidas después de la declaración. Diremos que esas
variables son globales o de ámbito global. El ámbito temporal de estas
variables es también global: se crean junto con el programa, y se destruyen
cuando el programa concluye. Las variables globales son las únicas que son
inicializadas automáticamente con valor cero cuando se declaran. Esto no sucede
con ninguna variable local. En todos los casos descritos, el ámbito temporal
coincide con el de acceso: las variables que no pueden ser accedidas es porque
no existen todavía o porque han sido destruídas. Más adelante veremos casos en
que estos ámbitos no coinciden. Una variable global declarada después de la
definición de una función no será accesible desde esa función, por eso,
normalmente se declaran las variables globales antes de definir las funciones.
Pero esto es hablando de forma general, en realidad, en C++ está mal
visto usar variables globales, ya que se consideran poco seguras.
Ejemplo:
int EnteroGlobal; // Declaración de una variable
global
int Funcion1(int a); // Declaración de un prototipo
int main() {
// Declaración de una variable local de main:
int EnteroLocal;
// Acceso a una variable local:
EnteroLocal = Funcion1(10);
// Acceso a una valiable global:
EnteroGlobal = Funcion1(EnteroLocal);
return 0;
}
int Funcion1(int a)
{
char CaracterLocal; // Variable local de funcion1
// Desde aquí podemos acceder a EnteroGlobal,
// y también a CaracterLocal
// pero no a EnteroLocal
if(EnteroGlobal
!= 0)
return a/EnteroGlobal;
return 0;
}
De modo
que en cuanto a los ámbitos locales tenemos varios niveles:
<tipo> funcion(parámetros) // (1)
{
<tipo> var1; // (2)
for(<tipo> var2;...) // (3)
...
<tipo> var3; // (4)
...
return var;
}
(1) Los parámetros se comportan
del mismo modo que variables locales, tienen ámbito local a la función.
(2) Las variables declaradas
aquí, también.
(3) Las declaradas en bucles,
son de ámbito local en el bucle.
(4) Las variables locales sólo
son accesibles a partir del lugar en que se declaren. Esta variable: var3,
es de ámbito local para la función, pero no es accesible en el código previo a
su declaración.
Es una
buena costumbre inicializar las variables locales. Los ámbitos pueden ser
alterados mediante ciertos modificadores que veremos en otros capítulos.
^Generalmente no es posible, y no
suele ser necesario, declarar dos variables con el mismo nombre, pero hay
condiciones bajo las cuales es posible hacerlo. Por ejemplo, podemos declarar una variable global con un nombre
determinado, y declarar otra variable (del mismo tipo o de otro diferente) de
forma local en una función, usando el mismo nombre. En ese caso decimos que la segunda declaración (la local),
enmascara a la primera (la global). Con eso queremos decir que el acceso a la
variable global está bloqueado o enmascarado por la local, que es a la única
que podemos acceder directamente.
Por ejemplo:
int x;
int main()
{
int x;
x = 10;
return 0;
}
En este
programa, cuando asignamos 10 a x estamos accediendo a la
versión local de la variable x. En la función main, la
variable global x está enmascarada, y no puede accederse a
ella directamente. Del mismo modo, una variable de ámbito de bucle o de ámbito
de bloque puede enmascarar a una variable global o local, o a una de un bloque
o bucle más externo:
int x = 10;
{
int x = 0;
for(int x = 0; x
< 10; x++) HacerAlgoCon(x);
}
En este
caso la declaración de x dentro del bloque enmascara la
declaración anterior, y a su vez, la declaración dentro del bucle for enmascara a la declaración del
bloque.
Otra cuestión sería qué utilidad pueda tener esto.
^Existe un método para acceder a
una variable global enmascarada por una variable local. Se trata del operador
de ámbito, que consiste en dos caracteres de dos puntos seguidos (::).
Veremos
este operador con más detalle en el capítulo dedicado a los espacios con
nombre, pero veamos ahora cómo lo podemos usar para acceder a una variable
global enmascarada:
int x; //
Variable global
int main()
{
int x; // Variable local que enmascara a la global
x = 10; // Accedemos a la variable local
::x = 100; // Mediante el operador de ámbito accedemos a la global
return 0;
}
El
operador de ámbito, usado de este modo, permite acceder al espacio de variables
global. Pero este no es más que un uso restringido del
operador, que tiene muchas más aplicaciones.
Función Main:
Todo
programa C++ tiene una función main( ) que es el punto inicial de entrada al
programa. Su estructura es:
main( )
{
… bloque de
estatutos
}
Los
estatutos incluidos entre las llaves {…} se denominan bloque.
Un programa
debe tener sólo una función main( ). Si se intenta hacer dos funciones main ( )
se produce un error.
Además de
la función main( ), un programa en C++, consta de una colección de funciones.
COMENTARIOS
Los comentarios son mensajes que el
programador escribe dentro del codigo, pero que el compilador no los detecta.
Se usan para documentar los programas de acuerdo a las necesidades del
programador. Existen dos formas de escribir comentarios
// (Doble slash) este par de caracteres
genera un comentario de una linea despues de su aparicion. Ejemplo:
int x=100; // declaración de la
variable x inicializada en 100
/* */(Slash asterisco asterisco slash) Este
comentario puede abarcar varias lineas de codigo. Todo lo que se encuentre en
medio de estas parejas de caracteres es un comentario.
ejemplo:
/* Programa ejemplo1
Desarrollado por: Samuel Padilla
Fecha: Agosto 10 de 2010 */
Ejemplo1:
PROGRAMA QUE IMPRIME UNA CADENA DE TEXTO CONSTANTE (para dev C++)
#include “iostream” //libreria o biblioteca
using namespace std;
int main( ){//en dev C++ no
se usa void main
cout<<“primer programa en C++”<<endl;
system(“pause”);
}
La
primera línea de código es una directiva y se usa para llamar un archivo
llamado iostream que contiene la funcion que nos permite imprimir en la
pantalla (leer en este blog la entrada DIRECTIVAS)
El programa
es básico, utiliza la funcion cout que esta en la libreria iostream
para imprimir en la pantalla lo que el usuario ubique dentro de las comillas.
Todos los
programas que desarrollemos en esta primera parte del curso tendran una
estructura similar. La diferencia estara en la parte encerrada entre corchetes
{ } es decir el bloque de codigo
ejemplo 2:
PROGRAMA CON VARIABLES DE TIPOS DE DATO SIMPLE INICIALIZADAS (para dev C++)
#include “iostream”
using namespace std;
int main(){
int x=1200;
float nota=4.9;
double largo=0.0000000001;
char miletra=’R’;
string c=”AMO la
programacion de computadoras”;
cout<<“La variable
entera fue iniciada en “<<x<<endl;
cout<<“La variable
flotante fue iniciada en “<<nota<<endl;
cout<<“La variable
doble precision fue iniciada en “<<largo<<endl;
cout<<“La variable
caracter fue iniciada en “<<miletra<<endl;
cout<<“La variable
cadena (string) fue iniciada en “<<c<<endl;
system(“pause”);
}
En el
codigo anterior se declara una variable de cada tipo, se inicializa y se
imprime.
Main C++


Comentarios
Publicar un comentario