COMPONENTES
3.Componentes 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
3.1 Directivas de preprocesamiento
Las directivas de
preprocesamiento son definidas para que el compilador realice algo antes de
compilar el programa (revisar si la sintaxis es correcta y generar un código
ejecutable por la computadora), como el incluir funciones de alguna biblioteca
conocida. En particular, en C la directiva para incluir bibliotecas es como las
siguientes:
Ejemplos:
#include “iostream.h”
Esta directiva permitirá utilizar la función de
lectura cin y la función de escritura cout propias
de C++.
#include “stdio.h”
Esta directiva permitirá utilizar las funciones de
lectura y escritura propias de C. Estas directivas también funcionan con C++,
aunque existen algunos compiladores que no las soportan en cuyo caso es
necesario hacer uso de los namespaces. Un namespace es una declaración de
región. El propósito de estos es localizar el nombre de identificadores para
evitar colisiones. Para tener compatibilidad, cuando un programa en C++
incluye una libreria de C, haremos uso del namespace.
Ejemplo:
En C
tenemos
#include “iostream.h”
Con el respectivo en
C++ #include “iostream”
using namespace std;
using namespace std;
3.2
Declaración de variables
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.
3.3 Función Main:
ANATOMIA DE UN PROGRAMA EN C++
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.
3.4 Funciones por el usuario
Creación de funciones definidad por el usuario
Las funciones de usuario son, como su nombre indica,
las que el propio usuario declara, de igual manera que declara procedimientos.
Las funciones nacen con el propósito de ser subprogramas que siempre tienen que
devolver algún valor.
Las funciones siempre devuelven un valor al programa
que las invocó.
Para llamar a un procedimiento se escribe su nombre
en el cuerpo del programa, y si los necesita, se incluyen los parámetros entre
paréntesis. Para invocar una función es necesario hacerlo en una expresión.
Las funciones de usuario vienen definidas por un
nombre, seguidas de dos paréntesis () entre los que puede haber o no
argumentos. Los argumentos son valores que se le pasan a la función cuando se
llama.
Un ejemplo de una función sin argumentos:
#include <stdio.h>
main ()
{
printf (“\nEste mensaje lo muestra la función
main()”);
MiFuncion ();
}
/* Definición de la función MiFuncion() */
MiFuncion ()
{
printf (“\nEste otro lo muestra MiFuncion()”);
}
En este ejemplo se utiliza la función MiFuncion()
para mostrar en pantalla una frase. Como se ve, MiFuncion() se invoca igual que
printf() o scanf(), es decir, simplemente se escribe el nombre de la función y
los paréntesis. La definición de MiFuncion() tiene el mismo aspecto que main():
el nombre de la función con los paréntesis y, seguidamente, el cuerpo de la
función encerrado entre llaves.
Un ejemplo de una función con argumentos. El
programa visualiza el cuadrado de un número entero por medio de una función que
recibe dicho número como argumento.
#include
<stdio.h>
main ()
{
int num;
printf (“\nTeclee un número entero: “);
scanf (“%d”, &num);
cuadrado (num);
}
/* Definición de la función cuadrado() */
cuadrado (int x)
{
printf (“\nEl cuadrado de %d es %d\n”, x, x * x);
}
Es la declaración de la función cuadrado(). Dentro de
los paréntesis se pone la variable que recibirá el valor pasado a cuadrado() y de qué tipo es. Así, si se teclea el
valor 6, se
almacena en num y al hacer la llamada cuadrado (num), la variable num se copia en la variable x, que es con la que
trabaja internamente la función cuadrado().
Es importante mantener claros dos términos:
1. El
término Argumento se refiere a la variable usada al
llamar la función.
2. El
término Parámetro Formal se refiere a la variable de una
función que recibe el valor de los argumentos.
También es importante tener claro que la copia de
variables se hace sólo en una dirección: del argumento al parámetro formal.
Cualquier modificación del parámetro formal realizado dentro de la función no
tiene ninguna influencia en el argumento.
Hay que tener en cuenta es que el tipo de argumento
que se utiliza para llamar a una función debe ser el mismo que el del parámetro
formal que recibe el valor. Así, no debe llamarse a la función cuadrado con un
argumento de tipo float.
Un ejemplo que utiliza una función que devuelve un
valor. El siguiente programa lee dos números enteros del teclado y muestra su
producto en pantalla. Para el cálculo se usa una función que recibe los dos
números y devuelve el producto de ambos.
#include
<stdio.h>
main ()
{
int a, b, producto;
printf (“\nTeclee dos números enteros: “);
scanf (“%d %d”, &a, &b);
producto = multiplica (a, b);
printf (“\nEl resultado es %d”, producto);
}
/* Definición de la función multiplica() */
multiplica (int x, int y)
{
return (x * y);
}
Comentarios
Publicar un comentario