C++ Variables y tipos: Int, Char, Float, Double, Cadena y bool

C++ Tipos de datos variables

C++ define un conjunto completo de tipos primitivos

La función vacío El tipo no tiene valores asociados y solo se puede utilizar en algunas circunstancias. Es más común como tipo de retorno de funciones que no devuelven un valor.

La función 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 flotanteLos números de coma flotante (o flotantes) 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 una precisión mayor que el mínimo especificado. Normalmente, los números de coma flotante se representan con 32 bits, los dobles con 64 bits y los dobles largos con 96 o 128 bits.
2. Tipos integrales (que incluyen caracteres, números enteros y tipos booleanos). El Boolean type tiene sólo dos tipos de valores: Verdadero o Falso. Hay varios tanque 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.

La función 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 contendrá valores desde –127 hasta 127.

Tipo sin firmar: 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 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 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;

La función C++ El idioma ha reservado algunos nombres para su uso.

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

• Un identificador debería 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 suelen comenzar con una letra mayúscula.
• Los identificadores que contienen varias palabras deben distinguir visualmente cada palabra. Por ejemplo, guru99_website, no guru99website.

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

Una declaración de una variable hace que el programa conozca un nombre en el ámbito en el que está definido. 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 un tamaño de beneficio variable que indica la cantidad de entradas que se tomarán del usuario. Aquí no queremos cambiar el valor de buffsize en todo el 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 constante después de crearlo, debe declararse e inicializarse obligatoriamente. De lo contrario, el compilador genera 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. Básicamente, se puede utilizar el mismo nombre para referirse a diferentes entidades dentro de diferentes ámbitos. Las variables son visibles desde el punto donde se declaran hasta el final del alcance 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 tres nombres: 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 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 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 a él desde su punto de declaración y desde el resto del cuerpo de la función principal. Sin embargo, no fuera de él. Esto significa que la suma variable tiene alcance del bloque.
• La variable val se define en el alcance de la "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 ámbito contenedor es el ámbito exterior.

#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. Así, esta salida

La declaración es la que utiliza el nombre reutilizado que está definido en el ámbito global. Esta declaración produce

de 42

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

de 0

Salida # 3 anula las reglas de alcance predeterminadas utilizando 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 recuperar el nombre en el lado derecho del alcance global. Por lo tanto, la expresión utiliza la reutilización global y genera

de 42

Conversión de tipo variable

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

La asignación de un valor no bool a una variable bool da como resultado 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 fraccionaria se convierta en cero. Generalmente se pierde precisión si el número entero tiene más bits de los que la variable flotante puede acomodar.

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, ambos inclusive. Asignar un valor fuera de este rango dará como resultado que el compilador asigne el resto de ese valor en 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 con signo, el resultado es impredecible. No está definido. Puede parecer que el programa funciona en el exterior, 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. Según 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 suele ser casi con seguridad incorrecto.

Precaución: no mezcle tipos firmados y sin firmar

Las expresiones que combinan con y sin signo pueden producir resultados sorprendentes y erróneos cuando el valor con signo es negativo. Como se mencionó anteriormente, los valores con signo se convierten automáticamente a 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 int, 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 número entero en la máquina compiladora. En nuestra máquina, esta expresión produce 4294967295.

Registrar variables

Las variables de registro son de acceso más rápido en comparación con las variables de memoria. Entonces, las variables que se usan frecuentemente en un C++ El programa se puede poner en registros usando Registro 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. Generalmente, los propios compiladores realizan varias optimizaciones que incluyen colocar algunas de las variables en el registro. No hay límite en el número de variables de registro en un C++ programa. 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 individuales. Los comentarios del programa son declaraciones explicativas. Se puede incluir en el C++ código que ayuda a cualquiera a leer 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.

• 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 \, el comentario continuará en la siguiente línea.
• Comentarios de varias líneas son los que empiezan con /* y terminan con */.

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

Secuencias de escape

Algunos caracteres, como la tecla de retroceso y los caracteres de 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.

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

¿Qué hacer?	Caracter
Nueva línea	\n
Pestaña vertical	\v
Barra invertida	\\
Retorno de carro	\r
Pestaña horizontal	\t
Retroceso	\b
Signo de interrogación	\?
Avance de formulario	\f
Alerta (campana)	\a
Double cotización inicial	\ "
Una frase	\ '

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 \ 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 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 newline
cout << '\115' << '\n';     // prints M followed by a newline 

Resumen

• A C++ La variable nos proporciona una capacidad de almacenamiento con nombre.
• C++ tipos de variables: int, double, tanque, flotador, cadena, 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 de acceso más rápido 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 de control, no tienen imagen visible.