Template blog

C++ : Practica 5: Operadores en C++

Operador de Asignación (=)
El operador de asignación atribuye un valor a una variable.

x = 5;

Esta declaración asigna el valor entero "integer" 5 a la variable x. En C++ la asignación de tareas operacionales siempre se desarrolla de derecha a izquierda y nunca de otra manera.

x = y;

Esta sentencia asigna a la variable x el valor contenido en la variable y. El valor de x en el momento en que se ejecuta esta sentencia, se pierde y es reemplazado por el valor de y.
Considere también que estamos asignando sólo el valor de y a x en el momento de la operación de asignación. Por lo tanto, si cambia en un momento posterior, no afectará al nuevo valor tomado por x.
Para ejemplificar esto echaremos un vistazo al siguiente código: He incluído la evolución del contenido almacenado en las variables, como comentários:

//operadores de asignación
#include "iostream"
using namespace std;

int main(){
    int a, b;  //a:?, b:?
    a = 10;   //a:10, b:?
    b = 4;    //a:10, b:4
    a = b;    //a:4, b:4
    b = 7;    //a:4, b:7

    cout << "a:";
    cout <<  a;
    cout << "b:";
    cout <<  b;
}

Este programa lo que hace es imprimir en pantalla los valores finales de a y b(4 y 7 respectivamente). Observe como la variable "a" no ha sido afectada por la modificación final de b, a pesar de haber declarado "a = b" antes.
Es importante saber que las operaciones de asignación son expresiones que pueden ser evaluadas. Esto quiere decir que la asignación en sí: tiene un valor; y para tipos fundamentales, este valor es el asignado en la operación. Veamos un ejemplo: <--c digo="" highlighter--="">

y = 2 + (x = 5);

<--fin codigo="" highlighter--="">En esta expresión, a y se le asigna el resultado de añadir 2 al valor de otra expresión de asignación (que tiene un valor de 5). Esto es más o menos equivalente a:

<--fin codigo="" highlighter--="">

x = 5;
y = 2 + x;

Con el resultado final de la asignación de 7 a y.

La siguiente expresión también es válida en C++:

x = y = z = 5;

Esto asigna 5 a las 3 variables (x y y z) siempre de derecha a izquierda, no lo olviden!

Operadores Aritméticos ( +, -, *, /, % )

Los 5 operadores soportados por el lenguaje C++ son:

*Operador*	*Descripción*
+	Adición
-	Sustracción
*	Multiplicación
/	División
%	Módulo

Las operaciones de suma, resta, multiplicación y división corresponden literalmente a sus respectivos operadores matemáticos. El último, operador de módulo, representado por un signo de porcentaje(%), el cual nos da el residuo de una división de 2 valores. Por ejemplo:

x = 11 % 3;

resulta en la x que contiene el valor 2, ya que dividir 11 por 3 resulta en 3, con un resto de 2.


Asignación Compuesta (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

Los operadores de Asignación Compuesta modifican el valor actual de una variable realizando una operación en ella. Son equivalentes a asignar el resultado de una operación al primer operando:

Expresión	Equivalente a...
y += x;	y = y + x;
x -= 5;	x = x - 5;
x /=y;	x = x / y;
precio *= unidades + 1;	precio = precio * (unidades + 1);

y lo mismo para todos los demás operadores de asignación compuestos. Por ejemplo:

//operadores de asignación compuestos
#include <iostream>
using namespace std;
int main ()
{
   int a, b = 3;
   a = b;
   a+= 2;  //equivalente a:  "a = a + 2"
   cout << a;
   return 0;
}

Incremento y Decremento (++, --)

Algunas expresiones pueden acortarse aún más: el operador de aumento (++) y el operador de disminución (--) aumentan o reducen en uno el valor almacenado en una variable. Son equivalentes a +=1 y -=1, respectivamente. Así:

++x;
x+=1;
x=x+1;

son todos equivalentes en su funcionalidad; los tres aumentan en uno el valor de x.

En los primeros compiladores de C, las tres expresiones anteriores podrían haber producido código ejecutable diferente dependiendo de cuál fué utilizado. En la actualidad, este tipo de optimización de código se realiza automáticamente por el compilador, por lo tanto, las tres expresiones deben producir exactamente el mismo código ejecutable.

Una peculiaridad de este operador es que puede usarse tanto como prefijo como sufijo. Esto significa que puede escribirse antes del nombre de la variable (++x) ó despues de la variable (x++). Aunque en expresiones simples como x++ ó ++x, ambos tienen el mismo significado; en otras expresiones donde se evalúa el resultado de la operación de incremento o decremento, pueden tener una diferencia importante en su significado. En el caso de que el operador de incremento se utilize como prefijo (++x) del valor, la expresión evalúa el valor de x, una vez que ya esta aumentado. Por otro lado, en el caso que se use como sufijo (x++), el valor tambien se incrementa, pero la expresión evalúa al valor que x tenía antes de ser incrementado. Observe la diferencia:

Ejemplo 1	Ejemplo 2
x = 3;	x = 3;
y = ++x;	y = x++;
//x contiene 4, y contiene 4	//x contiene 4, y contiene 3

En el Ejemplo 1, el valor asignado a y es el valor de x después de ser aumentado.
Mientras que en el Ejemplo 2, es el valor x antes de ser aumentado.

Operadores Relacionales y de Comparación ( ==, !=, >, <, >=, <= )

Se pueden comparar dos expresiones utilizando operadores relacionales y de igualdad. Por ejemplo, para saber si dos valores son iguales o si uno es mayor que el otro.

El resultado de tal operación es verdadero o falso (es decir, un valor booleano).

Los operadores relaciones en C++, son:

Operador	Descripción
==	igual a
!=	No es igual a
<	Menor que
>	Mayor que
<=	Menor que o igual a
>=	Mayor que o igual a

Aquí hay algunos ejemplos:

(7 == 5) // Se evalúa como falso
(5 > 4)  // Se evalúa como verdadero
(3 != 2)  // Se evalúa como verdadero
(6 >= 6) //Se evalúa como verdadero
(5 < 5)  //Se evalúa como falso

Operadores Lógicos ( !, &&, || )

El operador ! es el operador C++ para la operación booleana NOT. Tiene sólo un operando, a su derecha e invertido, produciendo false si su operando es true y true si su operando es false. Básicamente, devuelve el valor booleano opuesto de la evaluación de su operando. Por ejemplo:

!(5 == 5)  //evaluada como false porque la expresión a su derecha es true
!(6 <= 4)  //evaluada como true porque (6<=4) seria false
!true  // evaluada como false
!false  // evaluada como true

Los operadores lógicos && y || se utilizan al evaluar dos expresiones para obtener un solo resultado relacional. El operador && corresponde a la operación lógica booleana AND, que produce TRUE si ambos operandos son TRUE y FALSE en caso contrario. El panel siguiente muestra el resultado del operador && evaluando la expresión a&&b:

&& OPERATOR (and)
a	b	a && b
TRUE	TRUE	TRUE
TRUE	FALSE	FALSE
FALSE	TRUE	FALSE
FALSE	FALSE	FALSE

El operador || corresponde a la operacion Booleana OR, que devuelve TRUE si cualquiera de sus operandos es TRUE, siendo falsa sólo cuando ambos operandos son FALSE. Aquí están los resultados posibles de un a || b:

&& OPERATOR (or)
a	b	a \|\| b
TRUE	TRUE	TRUE
TRUE	FALSE	TRUE
FALSE	TRUE	TRUE
FALSE	FALSE	FALSE

Por ejemplo:

( (5 == 5) && (3 & 6) )  //evaluado para false (true && false)
( (5 == 5) || (3 & 6) )  //evaluado para true (true || false)

Cuando se utilizan los operadores lógicos, C++ sólo evalúa lo que es necesario de izquierda a derecha para obtener el resultado relacional combinado, ignorando el resto. Por lo tanto, en el último ejemplo ( (5 == 5) || (3 > 6) ), C++ evalúa primero si 5 == 5 es TRUE, y si es así, nunca verifica si 3 > 6 es TRUE ó no. Esto se conoce como evaluación de corto circuito y funciona de esta manera para estos operadores:

Operador	Corto Circuito
&&	si la expresión del lado izquierdo es FALSE, el resultado combinado es FALSE (la expresión del lado derecho nunca se evalúa).
\|\|	si la expresión del lado izquierdo es TRUE, el resultado combinado es TRUE (la expresión del lado derecho nunca se evalúa).

Esto es principalmente importante cuando la expresión de la derecha tiene efectos secundarios, como la alteración de los valores.

if (i < 10) && (++i > n) {/*...*/}  //Tenga en cuenta que la condición incrementa i

Aquí la expresión condicional combinada aumentaría i en uno, pero esto sólo si la condición a la izquierda de && es TRUE, porque de lo contrario, la condición en el lado derecho(++i < n) nunca se evalúa.

Operador terniario condicional ( ? )

Este operador condicional evalúa una expresión, devolviendo un valor si esa expresión se evalúa como TRUE y otra diferente si esa expresión se evalúa como FALSE. Su sintaxis es:

condicion ? resultado1 : resultado2

Si la condición es TRUE, toda la expresión evalúa el resultado1 y de la otra forma evaluará el resultado2. Veamos un ejemplo:

7 == 5 ? 4 : 3  //Se evalúa a 3, ya que 7 no es igual a 5.
7 == 5 + 2 ? 4 : 3  //Se evalúa a 4, ya que 7 es gual a 5 + 2.
5 > 3 ? a : b  //Se evalúa al valor de a, ya que 5 es mayor que 3.
a > b ? a : b  //Se evalúa según el que sea mayor a ó b.

Por ejemplo, veamos esto en la practica:

//operador condicional
#include(iostream)
using namespace std;
int main()
{
   int a,b,c;
   a = 2;
   b = 7;
   c = (a > b) ? a : b;
   cout << c << '\n';
   return 0;
}

En este ejemplo: a fue 2 y b fue 7, por lo que la expresión que está evaluando (a > b) no era TRUE, por lo tanto el primer valor especificado después de que el signo de interrogación fue descartado en favor del segundo valor (el único después del 'colon :') que era b (con un valor de 7).

Operador Coma ( , )

El operador Coma (,) es usado para separar 2 ó más expresiones que estan incluídas donde sólo se espera una expresión. Cuando el conjunto de expresiones tienen que ser evaluadas por un valor, sólo se considera la expresión que está más a la derecha.

Por ejemplo, vea el siguiente código:

a = (b = 3, b + 2);

Primero se asigna el valor 3 a b y luego se ha asignado b + 2 a la variable a. Así, al final, la variable a contendría el valor 5 mientras que la variable b contendría el valor de 3.

Operador de Conversión de Tipo Explícito

Los operadores de conversión de tipo permiten convertir un valor de un tipo dado a otro tipo. Hay varias maneras de hacer esto en C++. El más simple, que ha sido heredado del lenguaje C, es preceder a la expresión a ser convertida por el nuevo tipo encerrado entre paréntesis (()), observe:

int i;
float f = 3.14;
i = (int) f;

El código anterior convierte el numero flotante 3.14 en un valor entero (3); el resto se pierde. Aquí el operador de conversión de tipo fue (int). Otra forma de hacer lo mismo en C++ es usar la notación funcional que precede a la expresión a convertir, por el tipo y encerrar la expresión entre paréntesis:

i = int (f);

ambas formas de conversión de tipos son válidas en C++.

sizeof

Este operador acepta un parámetro que puede ser un tipo o una variable y devuelve el tamaño en bytes de ese tipo u objeto, veamos:

x = 5 + 7 % 2;

En C++, la expresión anterior siempre asigna 6 a la variable x, porque el operador % tiene una precedencia más alta que el operador + y siempre se evalúa antes. Partes de las expresiones se pueden encerrar entre paréntesis para anular este orden de precedencia ó para hacer explicitamente claro el efecto deseado. Observe la diferencia:

x = 5 + (7 % 2); // x = 6 (igual que sin paréntesis)
x = (5 + 7) % 2; // x = 0

De mayor a menor prioridad, los operadores C++ se evalúan en el siguiente orden:

Nivel	Grupo de Precedencia	Operador	Descripción	Agrupamiento
1	Ámbito o Escopo	`::`	Calificador de ámbito	De izquierda a derecha
2	Sufijo (Uranio ó con solo un operando y una variable de entrada)	`++ --`	Sufijo de incremento / decremento	De izquierda a derecha
		`()`	Formas funcionales
		`[]`	subíndice
		`. ->`	acceso a miembros
3	Prefijo (unario)	`++ --`	prefijo incremento / decremento	De derecha a izquierda
		`~ !`	bit a bit NOT / logical NOT
		`+ -`	prefijo unario
		`& *`	referencia / desreferencia
		`new delete`	asignación/desasignación
		`sizeof`	paquete de parámetros
		`(type)`	Conversión de tipo estilo C
4	Puntero a miembro	`.* ->*`	Puntero de Acceso	De izquierda a derecha
5	Aritmética: escalamiento	`* / %`	Multiplicando, dividir, módulo	De izquierda a Derecha
6	Aritmética: adición	`+ -`	adición, substracción	De izquierda a Derecha
7	Cambio de bit a bit	`<< >>`	Cambiar a la izquierda, Cambiar a la derecha	De izquierda a Derecha
8	Relacional	`< > <= >=`	Operadores de Comparación	De izquierda a Derecha
9	Equality	`== !=`	Igualdad / Desigualdad	De izquierda a Derecha
10	And	`&`	bit a bit AND	De izquierda a Derecha
11	Exclusive or	`^`	bit a bit XOR	De izquierda a Derecha
12	Inclusive or	`\|`	bit a bit OR	De izquierda a Derecha
13	Conjunction	`&&`	logical AND	De izquierda a Derecha
14	Disjunction	`\|\|`	logical OR	De izquierda a Derecha
15	Expresiones de nivel de asignación	`= *= /= %= += -= >>= <<= &= ^= \|=`	asignación / asignación compuesta	De derecha a izquierda
15	Expresiones de nivel de asignación	`?:`	Operador Condicional	De derecha a izquierda
16	Secuenciación	`,`	Separador Coma	De izquierda a Derecha

Cuando una expresión tiene dos operadores con el mismo nivel de precedencia, el agrupamiento determina cual se evaluará primero: de izquierda a derecha o de derecha a izquierda.
La inclusión de todas las sub-sentencias entre paréntesis(incluso aquellas innecesarias debido a su precedencia) mejora la legibilidad del código.

Habiendo entendido correctamente este capítulo, estaremos habilitados para praticar los ejemplos con diferentes valores. Esto hará más prolijo su camino hacia el entendimiento del lenguaje. Ya más adelante comenzaremos a crear mucho código interesante!. Repito!, no deje de practicar, eso es vital!

Aplicativo Constantes Inicio

C++ : Practica 4: Constantes en C++

Miguel Gaspar às 19:56 0

Las constantes son expresiones con un valor fijo.

Literales

Los Literales son el tipo más obvio de constantes. Expresan valores particulares dentro del código fuente de un programa. Ya hemos utilizado algunos literales en capítulos anteriores para dar valores específicos a variables o para expresar mensajes que queríamos imprimir en pantalla, como por ejemplo, cuando escribimos:

a = 5;

El 5 en este pedazo de código era una constante literal.
Las constantes literales se pueden clasificar en:

enteros integers,
punto flotante,
caracteres char,
cadenas strings,
booleanos bool,
punteros y
literales definidas por el usuario.

Números Enteros Integer:

1776
707
-273

Estas son constantes numéricas que identifican valores enteros integer. Tenga en cuenta que no se encierran entre comilllas o cualquier otro tipo carácter especial; ya que son una simple sucesión de cifras que representan un número entero en la base decimal; por ejemplo: 1776 representa siempre el valor mil setecientos setenta y séis.
Tambien tenemos los números decimales y C++ permite el uso de números octales (osea de base 8) y números hexadecimales (base 16) como constantes literales. Para literales octales, los dígitos están precedidos de un carácter 0 (cero). Y para hexadecimal, están precedidos por los caracteres 0x (cero, x). Por ejemplo, las siguientes contantes literales son todas equivalentes entre sí:

75
0113
0x4b

Todos ellos representan el mismo número que es: 75 (setenta y cinco) expresado como un numeral de base 10, numeral octal (0113) y numeral hexadecimal (0x4b), respectivamente.
Estas constantes literales tienen un tipo, al igual que las variables.
Por defecto, literales enteros son de tipo int. Sin embargo, ciertos sufijos pueden añadirse a un literal entero, para especificar un tipo de entero diferente:

Sufijo	Tipo de Modificador
u ó U
u ó U	unsigned
l ó L
l ó L	long
ll ó LL
ll ó LL	long long

Unsigned se puede combinar con cualquiera de los otros dos en cualquier orden para formar unsigned long ó unsigned long long.
Por ejemplo:

75    //int
75u    //unsigned int
75l    //long
75ul    //unsigned long
75lu    //unsigned long

En todos los casos encima, el sufijo puede ser especificado usando letras mayúsculas ó minúsculas.

Numeros de Punto Flotante

Expresan valores reales, con decimales y/o exponentes. Pueden incluir o un punto decimal ó un carácter e (que expresa "por diez elevado a la X", donde X es un valor entero que sigue al carácter e) ó un punto decimal y un carácter e, veamos todo esto en ejemplos:

3.14159    // 3.14159
6.02e23    // 6.02 x 10^23
1.6e-19    // 1.6 x 10^-19
3.0        // 3.0

Estos son cuatro números válidos con decimales, expresados en el lenguaje C++.

El primer numero es PI,
El segundo es el número de Avogadro,
El tercero es la carga eléctrica de un electrón (un número extremadamente pequeño) y
El cuarto es el número 3 expresado como literal numérico con punto flotante.

El tipo predetermiando para literales de punto flotante es double. Los literales de tipo flotante de tipo float ó long double se pueden especificar agregando uno de los siguientes sufijos:

Sufijo	Tipo
f ó F
f ó F	*float*
l ó L
l ó L	*long double*

Por ejemplo:

3.14159L    // long double
6.02e23f   // float

Cualquiera de las letras que pueden formar parte de una constante numérica de punto flotante (e, f ó l) pueden ser escritas utilizando letras mayúsculas o minúsculas sin diferencia de significado.

Literales de caracteres y strings

Los literales de caracteres y strings son colocados entre aspas ( ' ' ), veamos:

'z'
'p'
"Hello World"
"How do you do?"

Las dos primeras expresiones representan literales de un sólo carácter y las dos siguientes representan literales de strings compuestas de varios carácteres.
Observe que para representar un sólo carácter lo hemos incluído entre comillas simples ('z' ó 'p') y para expresar una string (que generalmente consta de más de un carácter), la incluimos con caracteres entre comillas dobles ( "Hello World" ó "How do you do?" ).
Los literales de un sólo carácter y de string requieren comillas que los rodeen para distinguirlos de posibles identificadores de variables o palabras claves reservadas. Observe la diferencia entre estas dos expresiones:

x
'x'

Aquí x sin aspas se refiere a un identificador, como el nombre de una variable o un tipo compuesto, mientras que 'x' (entre aspas simples) se referiría al carácter literal 'x' (o carácter que representa una letra minúscula x).
Caracteres y literales de strings tambien pueden representar caracteres especiales que son difíciles o imposibles de expresar de otra manera en el código fuente del programa, como por ejemplo nueva línea (\n) ó tab (\t). Estos caracteres especiales están todos precedidos por un carácter de barra invertida (\).
Aquí tiene usted una lista de códigos de escape de un sólo carácter:

Código de Escape	Descripción
\n
\n	Nueva línea
\r
\r	retornar
\t
\t	Tabulación
\v
\v	Tab Vertical
\b
\b	backspace
\f
\f	Feed de formulário (feed de página)
\a
\a	alert (beep)
\'
\'	Comilla simple single quote
\"
\"	Comilla Doble double quote
\?
\?	Simbolo de interrogación
\\
\\	back slash

Por ejemplo:

'\n'
'\t'
"izquierda \t Derecha"
"uno\ndos\ntres"

Internamente, las computadoras representan a estos personajes como códigos numéricos: los ordenadores normalmente usan una extensión del sistema de codificación de caracteres ASCII (para ver más informaciones entre aquí). Los caracteres tambien se pueden representar en literales usando su código numérico escribiendo un carácter de barra invertida (\) seguido por el código expresado como un número octal (base-8) ó hexadecimal (base 16).

Para un valor octal, la barra invertida es seguida directamente por los dígitos;
mientras que para un valor hexadecimal, un carácter x se inserta entre la barra diagonal invertida y los dígitos hexadecimales a continuación (por ejemplo: \x20 ó \ x4A).

Varios literales de string pueden ser concatenados para formar una cadena literal, esto se realiza simplemente separándolos por uno o más espacios en blanco, incluyendo pestañas tabs (\t), líneas nuevas newlines (\n) y otros caracteres en blanco válidos. Por ejemplo:

"esto forma" "una sola"     " cadena " 
"de caracteres"

Lo anterior es una cadena literal equivalente a:

"esto formauna sola cadena de caracteres"

Observe como los espacios dentro de las aspas son parte del literal mientras que los que estan fuera no lo son.

x = "string expresado en \
dos lineas"

es equivalente a:

x = "string expresado en dos lineas"

Todos los literales de caracteres y literales de strings descritos anteriormente están formados por caracteres de tipo char. Se puede especificar un tipo de carácter diferente utilizando uno de los siguientes prefijos:

Prefijo	Tipo de Carácter
u
u	char16_t
U
U	char32_t
L
L	wchar_t

Tenga en cuenta que, a diferencia de los sufijos de tipo para literales enteros, estos prefijos son sensibles a mayúsculas y minúsculas:

minúsculas para char16_t y
mayúsculas para char32_t y wchar_t

Para literales de cadenas, aparte de lo anterior u, U y L, existen dos prefijos adicionales:

Prefijo	Descripción
u8
u8	El literal de string se codifica en el ejecutable usando UTF-8
R
R	El literal de string es un string sin formato

En cadenas sin formato, las barras invertidas backslashes y las comillas simples y dobles son carácteres válidos; el contenido del literal está delimitado por un inicial R "secuencia (y un final) secuencia", donde secuencia es cualquier secuencia de caracteres(incluyendo una scuencia vacía).
El contenido de la cadena es lo que está dentro del paréntesis, ignorando la secuencia de delimitación en sí. Por ejemplo:

R"(string con \backslash) "
R"&%$(string con \backslash)&%$"

Ambas cadenas anteriores son equivalentes a "string con \\backslash". El prefijo R se puede combinar con cualquier otro prefijo, como u, L ó u8.

Otros Literales

Existen 3 literales de palabras claves en C++,

true,
false y
nullptr

true y false son los dos valores posibles para variables de tipo bool.

nullptr es el valor del puntero nulo.

bool foo = true;
bool bar = false;
int* p = nullptr;

Tipos de Expresiones Constantes

A veces, es conveniente dar un nombre a un valor constante:

const double pi = 3.1415926;
const char tab = '\t';

A continuación, podemos utilizar estos nombres en lugar de los literales que se definieron, veamos esto en un ejemplo práctico:

//constantes
#include <iostream>
using namespace std;
//declarando constantes
const double pi = 3.14159;
const char nuevalinea = '\n';

int main()
{
    //declarando variables
    double r = 5.0;  //radio
    double circulo;

    circulo = 2 * pi * r;
    cout << circulo;
    cout << nuevalinea; 
}

Definiciones de PreProcesador (#define)

Otro mecanismo para nombrar valores constantes es el uso de definiciones de preprocesador. Estos tienen el siguiente formato:

#define identifier replacement

Después de esta directiva #define, cualquier ocurrencia de identificador en el código se interpreta como reemplazo replacement, donde "replacement" es cualquier secuencia de caracteres (hasta el final de la línea).
Este reemplazo es realizado por el preprocesador y sucede antes de que el programa sea compilado, provocando así una especie de reemplazo ciego: la validez de los tipos o sintaxis involucradas, no serán comprobadas de ninguna manera.
Por ejemplo:

//constantes
#include <iostream>
using namespace std;
//declarando constantes
#define PI 3.14159
#define NUEVALINEA '\n'
int main()
{
    //declarando variables
    double r = 5.0;  //radio
    double circulo;

    circulo = 2 * pi * r;
    cout << circulo;
    cout << nuevalinea; 
}

Note usted que las lineas #define son directivas de pre-procesador y como tales son instrucciones de una sola línea - como las declaraciones C++ - no requieren punto y coma (;) al final, la directiva se extiende automáticamente hasta el final de la línea!, interezante no?

Culminado y entendido este paso, habremos llegado a una parte importante más de conocimientos para empezar a trabajar con C++, no podemos desistir si queremos llegar a desenvolver cualquier cosa con este maravilloso lenguaje!, más adelante veremos lo que son los Operadores en este lenguaje con lo cual iremos practicando con varios programas más complejos. No deje de practicar, eso es vital!

Pages

Axact Blogger Template

TRENDING NOW

C++ : Practica 5: Operadores en C++

Operadores Aritméticos ( +, -, *, /, % )

Asignación Compuesta (+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)

Incremento y Decremento (++, --)

Operadores Relacionales y de Comparación ( ==, !=, >, <, >=, <= )

Operadores Lógicos ( !, &&, || )

Operador terniario condicional ( ? )

Operador Coma ( , )

Operador de Conversión de Tipo Explícito

sizeof

C++ : Practica 4: Constantes en C++

Literales

Números Enteros Integer:

Numeros de Punto Flotante

Literales de caracteres y strings

Otros Literales

Tipos de Expresiones Constantes

Definiciones de PreProcesador (#define)

Recent Posts

Popular Posts

Recent Comments

Blogger news

Recent Posts

Random Post

Labels

Categories

Pages