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 para declarar variables en C ++
• Tipos de datos variables de C ++
• Nombre o identificadores de variable
• Const Qualifier 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 ++:

En t:

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 coma flotante de doble precisión. Ejemplo: 11.22, 2.345

Carbonizarse:

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

Flotador:

Un literal de coma flotante es un literal numérico que tiene forma fraccionaria o exponente. 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:

Tiene valor booleano verdadero o falso.

Reglas para declarar variables en C ++

A continuación, se muestran 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 utilizado en C ++ no puede ser una palabra clave. Por ejemplo, int es una palabra clave que se usa para denotar 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 tipo vacío no tiene valores asociados y solo se puede usar en unas pocas circunstancias. Es más comúnmente como el tipo de retorno de funciones que no devuelven un valor.

Los tipos aritméticos incluyen caracteres, números enteros, valores booleanos y números de punto flotante. Tipo aritmético si se divide en 2 categorías

1. Tipos de coma flotante . El flotante (o tipo flotante) representa 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. Normalmente, los flotantes se representan en 32 bits, los dobles en 64 bits y los dobles largos en 96 o 128 bits.
2. Tipos integrales (que incluyen caracteres, enteros y tipos booleanos). El tipo booleano tiene solo dos tipos de valores: verdadero o falso. Hay varias carbonilla 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 char tiene el mismo tamaño que un solo byte de máquina, es decir, un solo byte.

Los tipos integrales pueden estar firmados o sin firmar.

Tipo con signo : 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 contendrá valores de -127 a 127.

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

Nombre o identificadores de variable

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 a 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 ser guru99 en minúsculas, no Guru99 o GURU99.
• Las clases que definimos suelen comenzar 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 da a conocer un nombre al programa en el ámbito en el que está definida. Ejemplo:

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

int a,b;a=b=1000;

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

Const Qualifier en C ++

Suponga que hay una variable tamaño de búfer 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, use la palabra clave const

const int bufSize = 512; // input buffer size

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

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

const int i = get_size(); // ok: initialized at run timeconst int j = 42; // ok: initialized at compile timeconst int k; // error: k is uninitialized constint 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 intervalo de un programa en el que una variable tiene un significado. En general, el mismo nombre se puede usar para hacer referencia a diferentes entidades dentro de diferentes ámbitos. Las variables son visibles desde el punto en el que se declaran hasta el final del ámbito en el que aparece su declaración.

#include int main(){int sum = 0;// sum values from 1 through 10 inclusivefor (int val = 1; val <= 10; ++val)sum += val; // equivalent to sum = sum + valcout << "Sum of 1 to 10 inclusive is "<< sum <
Este programa define 3 nombres, a saber, principal, suma y val. Utiliza el nombre del 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 main, 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 ámbito global son accesibles en todo el programa.
La variable suma 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 a través del resto del cuerpo de la función principal. Sin embargo, no fuera de ella. Esto significa que la suma de la variable tiene alcance de bloque .
La variable val se define en el ámbito de "declaración for". Se puede usar fácilmente en esa declaración, pero no en otra parte de la función principal. Tiene alcance local .

Alcance anidado
El ámbito puede contener otros ámbitos. El ámbito contenido (o anidado) se denomina ámbito interno. El alcance contenedor es el alcance externo.
#include 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 nameint reused = 42; // reused has global scopeint main(){int unique = 0; // unique has block scope// output #1: uses global reused; prints 42 0cout << reused << " " << unique << endl;int reused = 0; // new, local object named reused hides global reused// output #2: uses local reused; prints 0 0cout << reused << " " << unique << endl;// output #3: explicitly requests the global reused; prints 42 0cout << ::reused << " " << unique << endl;return 0;}
La salida n. ° 1 aparece antes de la definición local de reutilizado. Por lo tanto, esta salida
La declaración es la que usa el nombre reutilizado que se define en el alcance global. Esta declaración produce
42 0
La salida n. ° 2 se produce 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 de global y genera
0 0
La salida n. ° 3 anula las reglas de alcance predeterminadas que utilizan el operador de alcance. El ámbito global no tiene nombre. Por lo tanto, cuando el operador de alcance (: :) tiene un lado izquierdo vacío. Lo interpreta como una solicitud para buscar el nombre en el lado derecho del alcance global. Por lo tanto, la expresión utiliza el global reutilizado y genera
42 0

Conversión de tipo de variable
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 produce falso si el valor es 0 y verdadero 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 punto 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 da como resultado que la parte fraccional se convierta en cero. Por lo general, la precisión se pierde si el número entero tiene más bits de los que puede admitir 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. La asignación de 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. No está definido. 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 truei = 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 a 0 o 1. Como resultado, usar un bool en una expresión aritmética es casi seguramente incorrecto.
Precaución: no mezcle tipos firmados y no firmados
Las expresiones que mezclan con y sin signo pueden producir resultados sorprendentes e incorrectos cuando el valor con signo es negativo. Como se mencionó anteriormente, los valores firmados se convierten automáticamente a sin firmar.
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 int, entonces el valor es, como se esperaba, -1.
Si x es int y y no tienen signo, entonces el valor de esta expresión depende de cuántos bits tiene un entero en la máquina compiladora. En nuestra máquina, esta expresión produce 4294967295.

Registrar variables
Las variables de registros 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 la palabra clave register . La palabra clave register le dice al compilador que almacene la variable dada en un registro. Es decisión del compilador ponerlo en un registro o no. Generalmente, 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 es posible que el compilador no almacene la variable en un registro. Esto se debe a que la memoria de registro es muy limitada y generalmente la utiliza el sistema operativo.
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 / programa fuente. Los comentarios vienen en forma de bloque o en líneas simples. 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 algún tipo de comentarios. C ++ admite comentarios de una sola línea y de varias líneas.

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

/* This is a comment *//* C++ comments can also* span multiple lines*/
 
Secuencias de escape
Algunos caracteres, como los de retroceso y control, no tienen una imagen visible. Estos 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 utilizar ninguno de estos caracteres directamente. En su lugar, podemos usar una secuencia de escape para representar dicho 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
 

\norte
 

 
 

Pestaña vertical
 

\ v
 

 
 

Barra invertida
 

\\
 

 
 

Retorno de carro
 

\ r
 

 
 

Pestaña horizontal
 

\ t
 

 
 

Retroceso
 

\B
 

 
 

Signo de interrogación
 

\?
 

 
 

Formfeed
 

\F
 

 
 

Alerta (campana)
 

\a
 

 
 

Cotización doble
 

\ "
 

 
 

Una frase
 

\ '
 

 

 

Usamos una secuencia de escape como si fuera un solo carácter:
cout << '\n'; // prints a newlinecout << "\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 una \ seguida 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 conjunto 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 newlinecout << '\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 alcance contenido (o anidado) se denomina alcance interno y el alcance contenedor es el alcance externo.
Una variable de un tipo se puede convertir en otro. Se conoce como "Conversión de tipo".
Las variables de registros 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 los de retroceso y control, no tienen una imagen visible.