Variables y tipos de C++:int, double, char, string, bool

Variables en C++

Una variable de C++ nos proporciona una capacidad de almacenamiento con nombre. Permite al programador manipular datos según la necesidad. Cada variable tiene un tipo en C++. El tipo de variable ayuda a determinar el tamaño y el diseño del mapa de memoria de la variable, el rango de valores que se pueden almacenar dentro de esa memoria y el conjunto de operaciones que se le pueden aplicar.

En este tutorial de C++, aprenderá:

Variables en C++
Tipos básicos de variables en C++
Reglas de declaración de variables en C++
Tipos de datos variables de C++
Nombre de variable o identificadores
Calificador constante en C++
Alcance de las variables en C++
Conversión de tipo de variable
Registrar variables
Secuencias de escape

Tipos básicos de variables en C++

Estos son los tipos básicos de variables de C++:

Int:

Un entero es un literal numérico (asociado con números) sin ninguna parte fraccionaria o exponencial. Ejemplo. 120, -90, etc.

Doble:

Es un valor de punto flotante de precisión doble. Ejemplo:11,22, 2,345

Carácter:

Un carácter literal se crea encerrando un solo carácter dentro de comillas simples. Por ejemplo:'a', 'm', 'F', 'P', '}', etc.

Flotante:

Un literal de coma flotante es un literal numérico que tiene una forma fraccionaria o exponencial. Por ejemplo:1.3, 2.6

Literales de cadena:

Un literal de cadena es una secuencia de caracteres entre comillas dobles. Por ejemplo:"¿Cómo estás?"

Bool:

Mantiene el valor booleano verdadero o falso.

Reglas de declaración de variables en C++

Estas son algunas reglas comunes para nombrar una variable:

Un nombre de variable de C++ solo puede tener letras, números y guiones bajos.
Un nombre de variable de C++ no puede comenzar con un número.
Los nombres de las variables no deben comenzar con un carácter en mayúscula.
Un nombre de variable usado en C++ no puede ser una palabra clave. Por ejemplo, int es una palabra clave que se usa para indicar números enteros.
Un nombre de variable de C++ puede comenzar con un guión bajo. Sin embargo, no se considera una buena práctica.

Tipos de datos variables de C++

C++ define un conjunto completo de tipos primitivos

El vacío type no tiene valores asociados y solo se puede usar en unas pocas circunstancias. Es más comúnmente como el tipo de devolución de funciones que no devuelven un valor.

Los tipos aritméticos incluir caracteres, números enteros, valores booleanos y números de coma flotante. Tipo aritmético si además se divide en 2 categorías

Tipos de punto flotante . Los float (o tipo flotante) representan números decimales. El estándar IEEE especifica un número mínimo de dígitos significativos. La mayoría de los compiladores suelen proporcionar más precisión que el mínimo especificado. Por lo general, los flotantes se representan en 32 bits, los dobles en 64 bits y los dobles largos en 96 o 128 bits.
Tipos integrales (que incluyen caracteres, enteros y tipos booleanos). El booleano type tiene sólo dos tipos de valores:True o False. Hay varios char tipos, la mayoría de los cuales existen para apoyar la internacionalización. El tipo de carácter más básico es char. Un carácter tiene el mismo tamaño que un solo byte de máquina, es decir, un solo byte.

Los tipos integrales puede estar firmado o sin firmar.

Tipo firmado :Representan números negativos o positivos (incluido el cero). En un tipo con signo, el rango debe dividirse uniformemente entre los valores +ve y -ve. Por lo tanto, un carácter con signo de 8 bits tendrá valores de –127 a 127.

Tipo sin firmar :En un tipo sin firmar, todos los valores son>=0. Un carácter sin firmar de 8 bits puede contener de 0 a 255 (ambos inclusive).

Nombre de variable o identificadores

Los identificadores pueden estar compuestos por algunas letras, dígitos y el carácter de subrayado o alguna combinación de ellos. No se impone ningún límite en la longitud del nombre.

Los identificadores deben

comience con una letra o un guión bajo ('_').
Y distinguen entre mayúsculas y minúsculas; las letras mayúsculas y minúsculas son distintas:

// define cuatro variables int diferentes

int guru99, gurU99, GuRu99, GURU99;

El lenguaje C++ ha reservado algunos nombres para su uso.

Hay muchas convenciones aceptadas para nombrar variables en diferentes lenguajes de programación. Seguir estas convenciones puede mejorar la legibilidad del programa.

Un identificador debe dar al menos alguna indicación de su significado.
Los nombres de las variables suelen estar en minúsculas:guru99, no Guru99 o GURU99.
Las clases que definimos generalmente comienzan con una letra mayúscula.
Los identificadores que contienen varias palabras deben distinguir visualmente cada palabra. Por ejemplo, guru99_website no guru99website.

Declaración y definición de variables de C++

Una declaración de una variable hace que el programa conozca un nombre en el ámbito en el que se define. Ejemplo:

int a=5;
int b;
char c='A';

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

Calificador constante en C++

Supongamos que hay una variable buffsize que indica el número de entradas que se tomarán del usuario. Aquí, no queremos cambiar el valor de buffsize a lo largo del programa. Queremos definir una variable cuyo valor sabemos que no debe cambiar.

En tal caso, utilice la palabra clave const

const int bufSize = 512;    // input buffer size

Esto define bufSize como una constante. Cualquier intento de asignar o cambiar bufSize genera un error.

Aquí, no podemos cambiar el valor de un objeto const después de que lo creamos, tiene que ser obligatorio declararlo e inicializarlo. De lo contrario, el compilador arroja un error.

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci

Alcance de las variables en C++

Un alcance es un lapso de un programa donde una variable tiene un significado. En su mayoría, el mismo nombre se puede usar para referirse a diferentes entidades dentro de diferentes ámbitos. Las variables son visibles desde el punto donde se declaran hasta el final del ámbito en el que aparece su declaración.

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}

Este programa define 3 nombres, a saber, main, sum y val. Utiliza el nombre de espacio de nombres std, junto con otros dos nombres de ese espacio de nombres:cout y endl.

El nombre de la función "principal" se define fuera de las llaves. El nombre de la función principal, como la mayoría de los otros nombres definidos fuera de una función, tiene un alcance global. Lo que significa que una vez declarados, los nombres que están en el alcance global son accesibles durante todo el programa.
La suma variable se define dentro del alcance del bloque que es el cuerpo de la función principal. Se puede acceder desde su punto de declaración y en el resto del cuerpo de la función principal. Sin embargo, no fuera de ella. Esto significa que la variable sum tiene alcance de bloque .
La variable val se define en el ámbito de "instrucción for". Se puede usar fácilmente en esa declaración, pero no en otra parte de la función principal. Tiene ámbito local .

Alcance anidado

El ámbito puede contener otros ámbitos. El ámbito contenido (o anidado) se denomina ámbito interno. El ámbito contenedor es el ámbito externo.

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}

Salida #1 aparece antes de la definición local de reutilizado. Por lo tanto, esta salida

declaración es la que utiliza el nombre reutilizado que se define en el ámbito global. Esta declaración genera

42 0

Salida #2 ocurre después de la definición local de reutilizado. Ahora está dentro del alcance. Por lo tanto, esta segunda declaración de salida simplemente usa el objeto local llamado reutilizado en lugar del global y genera

0 0

Salida #3 anula las reglas de ámbito predeterminadas mediante el operador de ámbito. El alcance global no tiene nombre. Por lo tanto, cuando el operador de alcance (::) tiene un lado izquierdo vacío. Lo interpreta como una solicitud para obtener el nombre en el lado derecho del ámbito global. Por lo tanto, la expresión usa la reutilización global y produce

42 0

Conversión de tipos de variables

Una variable de un tipo se puede convertir en otro. Se conoce como "Conversión de tipo". Veamos las reglas para convertir diferentes tipos de variables de C++:

La asignación de non-bool a una variable bool arroja false si el valor es 0 y true en caso contrario.

bool b = 42;            // b is true

La asignación de un bool a uno de los otros tipos aritméticos produce 1 si el bool es verdadero y 0 si el bool es falso.

bool b = true;
int i = b;              // i has value 1

Asignar un valor de coma flotante a una variable de tipo int produce el valor que se trunca. El valor que se almacena es la parte anterior al punto decimal.

int i = 3.14;               // i has value 3

La asignación de un valor int a una variable de tipo flotante hace que la parte fraccionaria se convierta en cero. La precisión generalmente se pierde si el número entero tiene más bits de los que puede acomodar la variable flotante.

Int i=3;
double pi = i;          // pi has value 3.0

Si intentamos asignar un valor fuera de rango a una variable de tipo sin signo, el resultado es el resto del valor %(módulo)

Por ejemplo, un tipo de carácter sin signo de 8 bits puede contener valores de 0 a 255, inclusive. Asignar un valor fuera de este rango dará como resultado que el compilador asigne el resto de ese valor módulo 256. Por lo tanto, según la lógica anterior, la asignación de -1 a un carácter sin signo de 8 bits le da a ese objeto el valor 255.

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

Si intentamos asignar un valor fuera de rango a un objeto de tipo firmado, el resultado es impredecible. Es indefinido. El programa puede parecer que funciona en el exterior, o puede fallar, o puede producir valores basura.

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

El compilador aplica este mismo tipo de conversiones cuando usamos un valor de un tipo donde se espera un valor de otro tipo.

int i = 42;
if (i) // condition will evaluate as true
i = 0;

Si este valor =0, entonces la condición es falsa; todos los demás valores (distintos de cero) dan como resultado verdadero. Por el mismo concepto, cuando usamos un bool en una expresión aritmética, su valor siempre se convierte en 0 o 1. Como resultado, usar un bool en una expresión aritmética casi seguramente es incorrecto.

Precaución:no mezcle tipos firmados y sin firmar

Las expresiones que mezclan con y sin signo pueden producir resultados sorprendentes y erróneos cuando el valor con signo es negativo. Como se discutió anteriormente, los valores con signo se convierten automáticamente en sin signo.

Por ejemplo, en una expresión aritmética como

x* y

Si x es -1 e y es 1, y si tanto x como y son enteros, entonces el valor es, como se esperaba, -1.

Si x es int e y no tienen signo, entonces el valor de esta expresión depende de cuántos bits tiene un entero en la máquina de compilación. En nuestra máquina, esta expresión produce 4294967295.

Registrar variables

Las variables de registro son más rápidas de acceder en comparación con las variables de memoria. Por lo tanto, las variables que se usan con frecuencia en un programa C++ se pueden colocar en registros usando registrar palabra clave. La palabra clave de registro le dice al compilador que almacene la variable dada en un registro. Es decisión del compilador ponerlo en un registro o no. En general, los propios compiladores realizan varias optimizaciones que incluyen poner algunas de las variables en el registro. No hay límite en el número de variables de registro en un programa C++. Pero el compilador no puede almacenar la variable en un registro. Esto se debe a que la memoria de registro es muy limitada y generalmente la utiliza el sistema operativo.

Para definir:

register int i;

Comentarios

Los comentarios son las partes del código ignoradas por el compilador. Permite al programador tomar notas en las áreas relevantes del código fuente/programa. Los comentarios vienen en forma de bloque o en líneas individuales. Los comentarios del programa son declaraciones explicativas. Se puede incluir en el código C++, lo que ayuda a cualquiera que lea su código fuente. Todos los lenguajes de programación permiten alguna forma de comentarios. C++ admite comentarios de una sola línea y de varias líneas.

Comentarios de una sola línea son las que comienzan con // y continúan hasta el final de la línea. Si el último carácter en una línea de comentario es \, el comentario continuará en la siguiente línea.
Comentarios de varias líneas son las que comienzan con /* y terminan con */.

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

Secuencias de escape

Algunos caracteres, como el retroceso y los caracteres de control, no tienen una imagen visible. Dichos caracteres se conocen como caracteres no imprimibles. Otros caracteres (comillas simples y dobles, signo de interrogación y barra invertida) tienen un significado especial en muchos lenguajes de programación.

Nuestros programas no pueden usar ninguno de estos caracteres directamente. En su lugar, podemos usar una secuencia de escape para representar tal carácter. Una secuencia de escape comienza con una barra invertida.

El lenguaje de programación C++ define varias secuencias de escape:

¿Qué hace? Personaje

Nueva línea

Pestaña vertical

barra invertida

Retorno de carro

Pestaña horizontal

Retroceso

Signo de interrogación

Avance de formulario

Alerta (campana)

Comillas dobles

\”

Comilla simple

\’

Usamos una secuencia de escape como si fuera un solo carácter:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline

También podemos escribir secuencias de escape generalizadas \x seguidas de uno o más dígitos hexadecimales. O usamos un \ seguido de uno, dos o tres dígitos octales. La secuencia de escape generalizada representa el valor numérico del carácter. Algunos ejemplos (asumiendo el juego de caracteres Latin-1):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M')

Podemos usar secuencias de escape predefinidas, como estamos usando cualquier otro carácter.

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline

Resumen

Una variable de C++ nos proporciona una capacidad de almacenamiento con nombre.
Tipos de variables de C++:int, double, char, float, string, bool, etc.
El ámbito contenido (o anidado) se denomina ámbito interno y el ámbito contenedor es el ámbito externo.
Una variable de un tipo se puede convertir en otro. Se conoce como "Conversión de tipo".
Las variables de registro son más rápidas de acceder en comparación con las variables de memoria.
Los comentarios son las partes del código ignoradas por el compilador.
Algunos caracteres, como el retroceso y los caracteres de control, no tienen una imagen visible.

Programa Hello World en C++ con explicación de código Matrices en C++ | Declarar | Inicializar | Ejemplos de puntero a matriz

Lenguaje C