Declaración de variables
Para poder usar una variable en C++, primero debemos declararla especificando
cual de los tipos de datos presentados arriba queremos que sea. La sintaxis para
declarar una nueva variable es escribir el especificador de tipo de dato que
queremos (como int, short,
float...) seguido por un identificador de variable. Por
ejemplo:
int a;
float mynumber;
Son declaraciones validas de variables. La primera declara una variable de
tipo int con el identificador a. La segunda
declara una variable de tipo float con el identificador
mynumber. Una vez declaradas, las variables a y
mynumber pueden ser usadas dentro del resto de su contexto en el
programa.
Si necesita declarar algunas variables del mismo tipo y quiere ahorrarse
escritura, puede declarar todas estas en la misma línea separando los
identificadores con comas ( , ). Por ejemplo:
int a, b, c;
declara tres variables (a, b y
c) de tipo int , y tiene exactamente el mismo
significado que si hubiéramos escrito:
int a;
int b;
int c;
El tipo de dato entero int (char,
short y long) pueden estar con sigo o sin signo
(signed or unsigned) de acuerdo al rango de números que necesitemos
representar. De este modo para especificar un tipo de dato entero lo hacemos
poniendo la palabra reservada signed o unsigned
antes del tipo de dato como tal. por ejemplo:
unsigned short NumberOfSons;
signed int MyAccountBalance;
Por defecto, si no especificamos signed o
unsigned se asume que el tipo de dato es signed,
además en la segunda declaración pudimos haber escrito:
int MyAccountBalance;
con exactamente el mismo resultado ya que es el modo mas usual, pocos códigos
incluyen la palabra reservada signed como parte del compendio de tipo de
nombres.
La única excepción de la regla es el tipo char que existe como tal
y es considerado de un tipo distinto al signed char y
unsigned char.
Finalmente, signed y unsigned pueden
también ser usados como tipos simples, significando lo mismo que signed
int y unsigned int respectivamente. Las siguientes dos
declaraciones son equivalentes:
unsigned MyBirthYear;
unsigned int MyBirthYear;
Para ver las declaraciones de variables en acción en un programa, vamos a
presentar el código C++ para el ejemplo de su memoria mental propuesto al inicio
de esta sección:
// operating with variables
#include <iostream>
using namespace std;
int main ()
{
// declaring variables:
int a, b;
int result;
// process:
a = 5;
b = 2;
a = a + 1;
result = a - b;
// print out the result:
cout << result;
// terminate the program:
return 0;
}
|
4 |
No se preocupe si algo en la declaración de variables luce un tanto extraña para
usted. Verá el resto en detalle en la siguientes secciones.
Inicialización de variables
Cuando declaramos una variable local, su valor es indeterminado por defecto.
Pero usted podría querer que una variable almacene un valor en concreto al momento
de su declaración. Para hacer esto, usted tiene que anexar un signo igual seguido
por el valor deseado en la declaración de la variable:
type identifier = initial_value ;
Por ejemplo, si queremos declarar una variable entera int
llamada a que contenga el valor 0 al momento en
el cual es declarada, podríamos escribir:
int a = 0;
Adicionalmente a esta forma de inicialización de variables (conocida como
c-like), C++ ha añadido una nueva manera de inicializar una variable: encerrando
el valor inicial entre paréntesis ():
type identifier (initial_value) ;
por ejemplo:
int a (0);
Ambas formas son validas y equivalentes en C++.
Contexto de variables
Todas la variables que están siendo usadas deben estar
previamente declaradas. Una diferencia importante entre los lenguajes C y C++,
es que en C++ podemos declarar variables en cualquier lugar del código fuente,
hasta entre dos sentencias ejecutables, y no sólamente al inicio del bloque de
instrucciones, como ocurre en C.
De todos modos, es recomendable bajo ciertas circunstancias seguir las
indicaciones del lenguaje C cuando declaremos variables, ya que puede ser útil
durante la depuración de un programa que tiene agrupadas todas las declaraciones
en un mismo sitio. Además el tradicional modo C-like de declarar variables
contempla incluir las declaraciones al comienzo de cada función (para variables
locales) o directamente en el cuerpo del programa, fuera de cualquier
función (para variables globales).
 Variables Globales pueden ser referidas
a cualquier lugar del código, dentro de una función, siempre y cuando esté
después de la declaración.
El contexto de las variables locales está limitado al
nivel de código en el cual son declaradas. Si ellas son declaradas al inicio
de una función (como en main) su contexto es toda la
función main. En el ejemplo contiguo, esto significa que
si otra función que exista aparte de la función main(), las
variables locales declaradas en main no podrían ser usadas
en otra función y viceversa. En C++, el contexto de una variable local está dado por el bloque en el que es declarada (un bloque es un grupo de instrucciones agrupadas dentro de los símbolos "llaves" {}). Si esta es declarada dentro de una función su contexto será el contexto de la función, si es declarada dentro de un lazo, su contexto sería solo el lazo, etc... En adición a los contextos locales y globales existen contextos externos, que hacen que una variable sea visible no solo en el mismo código fuente sino en todos los demás archivos que serán enlazados. |
Constantes: Literales.
Una constante es cualquier expresión que tenga un valor arreglado. Estos pueden
ser divididos en números Enteros, números Punto-Flotante, Cadenas y símbolos.
Números Enteros
1776
707
-273
Estas son constantes numéricas que identifican números enteros decimales. Note
que para expresar una constante numéricas no necesitamos escribir comillas
(") ni otro símbolo especial. No hay duda de que es una constante
dondequiera que se escriba 1776 en un programa, nos estaremos
refiriendo a el valor 1776.
En adición a los números decimales (esos que ya todos nosotros conocemos)
C++ permite el uso de constantes literales de números octales (base 8) y números
hexadecimales (base 16). Si queremos expresar un número octal debemos precederlo
con un símbolo 0 (caracter cero). Y para expresar un número
hexadecimal tenemos que precederlo con los símbolos 0x (cero, x).
Por ejemplo, las siguientes constantes literales son todas equivalentes entre
si:
75 // decimal 0113 // octal 0x4b // hexadecimal
Todas representan el mismo numero: 75 (setenta y cinco ) expresado como un
número base 10, octal y hexdecimal, respectivamente.
Números Punto Flotante
Estos expresan números con decimales y/o
exponentes. Estos pueden incluir un punto decimal, un símbolo e
(que expresa "por 10 a la n-esima potencia", donde n es el siguiente valor
entero) o ambos.
3.14159 // 3.14159 6.02e23 // 6.02 x 1023 1.6e-19 // 1.6 x 10-19 3.0 // 3.0
estos son cuatro números válidos con decimales expresados en C++. El primer
número es PI, el segundo es el numero de Avogadro, el tercero es la carga
eléctrica de un electrón (un número extremadamente pequeño) -todos ellos aproximados-
y el último es el número 3 expresado como un literal numérico en punto
flotante.
Caracteres y cadenas
También existen constantes no numéricas, como:
'z'
'p'
"Hola mundo"
"¿Como te va?"
Las primeras dos expresiones representas símbolos simples (solos) y las
siguientes dos representan cadenas de varios caracteres. Note que para representar
un caracter simple se encierra entre comillas simples (') y para expresar
una cadena de más de un caracter los encerramos entre comillas dobles (").
Cuando escribimos caracteres y cadenas de caracteres de manera constante, es
necesario poner las comillas para distinguirlas the posibles identificadores de
variables o palabras reservadas. Note esto:
x
'x'
x se refiere a la variable x, mientras que
'x' se refiere al caracter constante 'x'.
Los caracteres constantes y las cadenas constantes tienen ciertas peculiaridades,
como los escape codes o caracteres especiales como los llamaremos en
adelante, que no pueden ser expresados de otro modo en el código fuente de un
programa, como el símbolo de nueva línea (\n) o tabulado
(\t). Todos estos están precedidos por el símbolo slash
invertido(\). aquí tiene una lista de tales símbolos especiales:
\n nueva línea \r retorno de carro \t tabulación \v tabulación vertical \b backspace \f alimentación de pagina \a alerta (beep) \' comilla simple (') \" comilla doble (") \? interrogación (?) \\ slash invertido(\)
Por ejemplo:
'\n'
'\t'
"Left \t Right"
"one\ntwo\nthree"
Adicionalmente, usted puede expresar cualquier símbolo por su correspondiente
valor numérico en código ASCII escribiendo slash invertido (\)
seguido por el código ASCII expresado como un número octal (base 8) o hexadecimal
(base 16). En el primer caso (octal) el número debe seguir inmediatamente el slash
invertido (por ejemplo \23 o \40), en el segundo
caso (hexacedimal), usted debe poner un símbolo x antes del número
(por ejemplo \x20 o \x4A).
Las constantes de cadenas de caracteres pueden extenderse de una simple línea de
código si cada línea de código termina con un slash invertido (\):
"string expressed in \
two lines"
Usted puede también econcatenar varias cadenas constantes separándolas por uno o
varios blankspaces, tabuladores, nueva línea o cualquier otro de los caracteres blank
válidos:
"we form" "a single" "string" "of characters"
Constantes definidas como Macros (#define)
Usted puede definir sus propios nombres para constantes que usará
completamente sin tener que recurrir a variables, simplemente usando la
directiva del preprocesador #define. Este es su formato:
#define identificador valor
Por ejemplo:
#define PI 3.14159265
#define NEWLINE '\n'
#define WIDTH 100
Ellos definen tres nuevas constantes. Una vez declarados, usted estar᠍
habilitado para usarlos en el resto del código tal y como si fueran cualquier otra
constante, por ejemplo:
circle = 2 * PI * r;
cout << NEWLINE;
En realidad lo único que el compilador hace cuando encuentra directivas
#define es reemplazar literalmente cualquier ocurrencia de ellos
(en el ejemplo previo, PI, NEWLINE o
WIDTH) por el código al cual fueron definidos
(3.14159265, '\n' y 100,
respectivamente). Por esta razón #define constantes consideradas como
macro constantes.
La directiva #define no es una instrucción de código, es una directiva
del preprocesador, además asume que toda la línea es la directiva y no requiere un
punto y coma (;) al final de la misma. Si usted incluye un símbolo de
punto y coma (;) al final, este también será añadido cuando el preprocesador
sustituya cualquier ocurrencia de la constante definida dentro del cuerpo del
programa.
Constantes declaradas (const)
con el prefijo const usted puede declarar constantes con un
tipo especifico exactamente igual a como haría con una variable:
const int width = 100;
const char tab = '\t';
const zip = 12440;
En caso de que el tipo no sea especificado (como en el ultimo ejemplo) el
compilador asume que es de tipo int.
Información recopilada por Antony Loza
Estudiante Ing. Sistemas
Profesor: Jesús García Valdespino.
Unefa - Extensión Ocumare del tuy
ESTADO MIRANDA
VENEZUELA
No hay comentarios:
Publicar un comentario