PARTE 5

Pilas

Acceso limitado al ultimo elemento insertado ´
Operaciones basicas: ´ apilar, desapilar y cima.
desapilar o cima en una pila vacıa es un error en el TDA pila.
Quedarse sin espacio al apilar es un error de implementacion. ´
Cada operacion deberıa tardar una cantidad constante de tiempo
en ejecutarse.
Con independencia del numero de elementos apiladas.

Colas

Operaciones basicas: ´ insertar, quitarPrimero y primero.
Cada rutina deber´ıa ejecutarse en tiempo constante.
Implementacion circular a base de vectores (i) ´

La implementacion circular devuelve ´ cabeza y fin al principo del
vector cuando rebasan la ultima posici ´ on. ´
final
1) Crear Cola (C)
c
Implementacion circular a base de vectores (i) ´
La implementacion circular devuelve ´ cabeza y fin al principo del
vector cuando rebasan la ultima posici ´ on. ´
final
1) Crear Cola (C)
cabeza
final
2) Insertar en Cola (a,C) a
cabeza

Listas

Operaciones basicas: ´
Visualizar su contenido.
Buscar la posicion de la primera ocurrencia de un elemento. ´
Insertar y Eliminar un elemento en alguna posicion. ´
Buscar k esimo, que devuelve el elemento
de la posicion indicada


Implementacion de listas a base de vectores ´
Tiene que declararse el tamano de la lista. ˜
Exige sobrevaloracion. ´
Consume mucho espacio.
Complejidad computacional de las operaciones:
Buscar k esimo, tiempo constante
Visualizar y Buscar, tiempo lineal.
Insertar y Eliminar son costosas.
Insertar o eliminar un elemento exige, en promedio,
desplazar la mitad de los valores, O(n).
La construccion de una lista o la eliminaci ´ on´
de todos sus elementos podr´ıa exigir un tiempo cuadratico.

Implementacion de listas a base de apuntadores ´
Cada nodo apunta al siguiente; el ultimo no apunta a nada. ´
La lista es un puntero al primer nodo (y al ultimo). ´
Complejidad computacional de las operaciones:
Visualizar y Buscar, tiempo lineal.
Buscar k esimo, tiempo lineal.
Eliminar realiza un cambio de apuntadores y
una orden dispose, O(1).
Usa Buscar anterior cuyo tiempo de ejecucion es lineal. ´
Insertar tras una posicion´ p require una llamada a new y
dos maniobras con apuntadores, O(1).
Buscar la posicion´ p podr´ıa llevar tiempo lineal.
Un nodo cabecera facilita la insercion y la eliminaci ´ on al comienzo ´
de la lista.

Implementacion de listas doblemente enlazadas ´

Cada nodo apunta al siguiente y al anterior.

Duplica el uso de la memoria necesaria para los punteros.

Duplica el coste de manejo de punteros al insertar y eliminar.

La eliminacion se simplifica. ´

No es necesario buscar el elemento anterior.

PARTE 4

APUNTADORES

Una de las cosas más difíciles que encuentran los principiantes en C es entender el concepto de
apuntadores. El propósito de este documento es dar una introducción sobre apuntadores y de su uso a estos
principiantes.
Me he encontrado a menudo que la principal razón por la que los principiantes tienen problemas con los
apuntadores es que tienen una muy pobre o mínima concepción de las variables, (del modo en que C hace uso
de ellas). Así que comencemos con una discusión sobre las variables de C en general.

#include <stdio.h>
int j, k;
int *ptr;
int main (void)
{
 j = 1;
 k = 2;
 ptr = &k;
 printf("\n");
 printf("j tiene el valor: %d y esta alojado en: %p\n", j, (void *)&j);
 printf("k tiene el valor: %d y esta alojado en: %p\n", k, (void *)&k);
 printf("ptr tiene el valor: %p y esta alojado en: %p\n", ptr, (void *)&ptr);
 printf("El valor del entero al que apunta ptr es: %d\n", *ptr);
 return 0;
}
Nota: Aún tenemos que discutir los aspectos de C que requieren el uso de la expresión (void *) usada aquí.
Por el momento inclúyela en el código de prueba. Ya explicaremos las razones de esta expresión más adelante.

ARREGLOS UNIDIMENSIONALES

Los arreglos (arrays) permiten almacenar vectores y matrices. Los arreglos unidimensionales

sirven para manejar vectores y los arreglos bidimensionales para matrices. Sin embargo, las matrices

tambi´en se pueden almacenar mediante arreglos unidimensionales y por medio de apuntadores a

apuntadores, temas que se ver´an en el cap´ıtulo siguiente.

La palabra unidimensional no indica que se trata de vectores en espacios de dimensi´on uno; indica

que su manejo se hace mediante un sub´ındice. El manejo de los arreglos bidimensionales se hace mediante

dos sub´ındices.

#include <stdio.h>

int mi_arreglo[] = {1,23,17,4,-5,100};

int *ptr;

int main(void)

{

 int i;

 ptr = &mi_arreglo[0]; /* apuntamos nuestro puntero

 al primer elemento del arreglo*/

 printf("\n\n");

 for (i = 0; i < 6; i++)

 {

 printf("mi_arreglo[%d] = %d ", i, mi_arreglo[i]); /*<-- A */

 printf("ptr + %d = %d\n",i, *(ptr + i)); /*<-- B */

 }

 return 0;

}

ARREGLOS MULTIDIMENCIONALES

La declaraci´on de los arreglos bidimensionales, caso particular de los arreglos multidimensionales, se

hace como en el siguiente ejemplo:

double a[3][4];

int pos[10][40];

char list[25][25];

En la primera l´ınea se reserva espacio para 3 × 4 = 12 elementos doble precisi´on. El primer sub´ındice

var´ıa entre 0 y 2, y el segundo var´ıa entre 0 y 3. Usualmente, de manera an´aloga a las matrices, se dice

que el primer sub´ındice indica la fila y el segundo sub´ındice indica la columna.

Un arreglo tridimensional se declarar´ıa as´ı:

double c[20][30][10];

OPERACIONES CON ARREGLOS

La operaciones con arreglos se hacen principalmente con un for de manera que pides un incremento de variable de uno en uno llamada contador seguida de asignarle el valor a cada variable del arreglo asignado el contador como la variable a la que se le estará asignando un valor
para imprimir sera de la misma manera de la cual mandaremos a imprimir cada uno delos datos los cuales se mohatraran dentro de un for con un contador y este mostrara cada una de las posiciones de nuestro arreglo

parte 3.

Definición y prototipos de funciones

Los programas sencillos, como los ejemplo planteados hasta ahora, normalmente no requieren un nivel de estructuración elevado. Pero cuando estos crecen un poco necesitamos estructurarlos adecuadamente para mantenerlos legibles, facilitar su mantenimiento y reutilizar ciertas porciones de código. El mecanismo C que nos permite esto son las funciones. Con los compiladores, los fabricantes nos proporcionan un conjunto importante de funciones de librería. A veces, nos puede interesar construir nuestras propias librerías. Ya hemos utilizado funciones, pero veamos cómo debemos definirlas.
Los prototipos de funciones son una característica clave de la recomendación ANSI del C. Un prototipo es una declaración que toma la forma:

tipo nombre ( tipo_parámetro nombre_parámetro ... ); 

Aquí tenemos varios ejemplos:

int fact_i ( int v );
int mayor ( int a, int b );
int cero ( double a );
long raiz ( long valor );
void final_countdown ( void );
int main ( int argc, char **argv );

Observando el prototipo de una función podemos decir exactamente qué tipo de parámetros necesita y qué resultado devuelve. Si una función tiene como argumento void, quiere decir que no tiene argumentos, al igual que si el resultado es void, no devuelve ningún valor. En la vieja definición de Kernighan y Ritchie el tipo que devolvía una función se declaraba únicamente si era distinto de int. Los parámetros eran declarados en el cuerpo de la función, en lugar de utilizar la lista de parámetros. Por ejemplo:

mayor ( a, b )
int a; int b;
{
...
} 

ESTRUCTURA DE UNA FUNCION

#include <stdio.h>

void holamundo(void) /*Esta es la declaracion y a la vez la definicion de la funcion*/

{

  printf("Hola Mundo\n"); /* Esto lo que imprimira nuestra funcion */

return; /* sale de la función */

}

int main(void) /* Función principal del programa */

{

holamundo(); /* llamada a la función holamundo */

return 0; /* sale del programa con código 0 (correcto) */

}

Parámetros por referencia a funciones

En C todos los parámetros se pasan por valor. Esto tiene en principio dos inconvenientes: 

• No se pueden modificar variables pasadas como argumentos
• Si se pasa como parámetro una estructura, se realiza un duplicado de ella, con lo que se pierde tiempo y memoria

Sin embargo, se puede pasar un puntero como argumento a una función. El puntero no se puede alterar, pero sí el valor al que apunta: 

void incrementa_variable (int* var)
{
   (*var)++;
}

main()
{
   int x = 1;
   incrementa_variable (&x); /* x pasa a valer 2 */
}

En el ejemplo anterior, había que poner paréntesis en (*var)++ porque el operador ++ tiene más precedencia que la referencia (el asterisco). Entonces *var++ sería como escribir *(var++), que no sería lo que queremos. 

Se dice que una función es recursiva cuando se define en función de si misma.

No todas la funciones pueden llamarse a si mismas, sino que deben estar diseñadas especialmente para que sean re cursivas, de otro modo podrían conducir a bucles infinitos, o a que el programa termine in adecuadamente.

Tampoco todos los lenguajes de programación permiten usar recursividad.

C++ permite la recursividad. Cada vez que se llama a una función, se crea un juego de variables locales, de este modo, si la función hace una llamada a si misma, se guardan sus variables y parámetros, usando la pila, y la nueva instancia de la función trabajará con su propia copia de las variables locales. Cuando esta segunda instancia de la función retorna, recupera las variables y los parámetros de la pila y continua la ejecución en el punto en que había sido llamada.

Por ejemplo:

Podríamos crear una función recursiva para calcular el factorial de un número entero.

El factorial se simboliza como n!, se lee como "n factorial", y la definición es:

n! = n * (n-1) * (n-2) * ... * 1

Hay algunas limitaciones:

• No es posible calcular el factorial de números negativos, no está definido.
• El factorial de cero es 1.

De modo que una función bien hecha para cálculo de factoriales debería incluir un control para esos casos:

/* Función recursiva para cálculo de factoriales */
int factorial(int n) {
   if(n < 0) return 0;
   else if(n > 1) return n*factorial(n-1); /* Recursividad */
   return 1; /* Condición de terminación, n == 1 */
}

Parte 2

Parte 1

Definición de proposición y bloque.

BLOQUE

Es un conjunto de sentencias individuales que se encuentran incluidas dentro de un par de llaver

{

      sentencia1;

      sentencia2;

      sentenciaN;

}

PROPOSICIÓN SIMPLE

Son sentencias lógicas dentro del programa que puede tomar solo una de los valores

FALSO O VERDADERO

considerando que x=5 y z=1

x es mayor que 3 VERDADERO        if (x>3)

z es negativo FALSO                          if (z<0)

PROPOSICIÓN COMPUESTA

volviendo considerar que x=5 y z=1

x es menor que 45 y                                if (x<45&&z>0)

z es mayor que 0 VERDADERO          

CONTADOR

un contador es una variable la cual incrementa de ya sea de uno en uno o de los números que deseemos generalmente se encuentra dentro de una función  for

for (i=0;i<=50;i+1)

BANDERA

Las banderas, son variables que toman solo unos pocos valores preestablecidos, que se usan para una posterior selección de tareas o par indicar algún error que no es fatal(que no causa el municionamiento general o que el programa se clave) 
Otra cosa es que el programa reciba parámetros, esto segundo es bastante mas complicado y no tiene nada que ver con banderas 

Una bandera, puede ser para una resta, 
ingresar numero1 
ingresar numero2 
si numero 2 es mayor que numero 1 flag = 1; 
else flag = 0; 
si flag = 1 
resultado = numero2 - numero1 
si flag = 0 
resultado = numero1 - numero2 

Estructuras de control

En lenguajes de programación, las estructuras de control permiten modificar el flujo de ejecución de las instrucciones de un programa.

Con las estructuras de control se puede:

• De acuerdo a una condición, ejecutar un grupo u otro de sentencias (If-Then-Else)
• De acuerdo al valor de una variable, ejecutar un grupo u otro de sentencias (Select-Case)
• Ejecutar un grupo de sentencias mientras se cumpla una condición (Do-While)
• Ejecutar un grupo de sentencias hasta que se cumpla una condición (Do-Until)
• Ejecutar un grupo de sentencias un número determinado de veces (For-Next)

Todas las estructuras de control tienen un único punto de entrada y un único punto de salida. Las estructuras de control se puede clasificar en : secuenciales, iterativas y de control avanzadas. Esto es una de las cosas que permite que la programación se rija por los principios de la programación estructurada.

Los lenguajes de programación modernos tienen estructuras de control similares. Básicamente lo que varía entre las estructuras de control de los diferentes lenguajes es su sintaxis, cada lenguaje tiene una sintaxis propia para expresar la estructura.

Otros lenguajes ofrecen estructuras diferentes, como por ejemplo los comandos guardados.

 Estructuras: secuencia, selectivas

IF

if (edad < 18) 
  printf("No puedes acceder.\n");
 else
  printf("Bienvenido.\n");

if (condición) {
  sentencias_si_verdadero;
 } else {
  sentencias_si_falso;
 }






SWITCH

#include <stdio.h>
#include <stdlib.h>
 
int main(void) {
 int dia;
 
 printf("que número de día de la semana es?");
 scanf("%d",&dia);
 
 switch(dia) {
  case 1 :
   printf("Lun, Lunes");
   break;
  case 2 :
   printf("Mar, Martes");
   break;
  case 3 :
   printf("Mier, Miercoles");
   break;
  case 4 :
   printf("Jue, Jueves");
   break;
  case 5 :
   printf("Vie, Viernes");
   break;
  case 6 :
   printf("Sab, Sabado");
   break;
  case 7 :
   printf("Dom, Domingo");
   break;
  default :
   printf("No existe");
}
return 0;
}

while

int i = 0;
while (i < 100) {
 printf("%d\n", i);
 i = i + 1;
}







for

for (/* inicialización */; /* condición */; /* incremento */) {
 /* código a ejecutar */
}


int i;
for (i=0; i < 100; i = i + 1) {
 printf("%d\n", i);
}










DO WHILE




do {
 /* CODIGO */
} while (/* Condición de ejecución del bucle */)




les muestro un ejemplo sencillo


int aleatorio;
do {
 aleatorio = rand();
} while (aleatorio != 25);


________________________________________________________________________________

goto


La sentencia goto sirve para indicar al programa que continue ejecutándose desde la línea de código indicada. Su sintaxis es más o menos así:


/* Código */
ETIQUETA:
/* Código */
goto ETIQUETA;
/* Código */




Así, cuando se ejecute la sentencia goto, el programa "saltará" y continuará su ejecución a partir de la etiqueta marcada.

Como se puede observar se puede usar para crear un bucle, o para ir a una parte del código u otra si se combina con una sentencia if...else. Pero por lo general puede obtenerse el mismo efecto utilizando los bucles anteriormente vistos.

Por eso, la sentencia goto es poco aceptada por la comunidad de programadores, pues puede provocar que se hagan programas un poco "sucios" y confusos. Sólo en ocasiones muy excepcionales será recomendado el uso del goto al crear iteraciones muy complejas. Sin embargo, con el pasar de los años este comando ya ha quedado prácticamente descartado del lenguaje de los programadores.








break;



La instrucción de salto break se usa para interrumpir (romper) la ejecución normal de un bucle, es decir, la instrucción break finaliza (termina) la ejecución de un bucle y, por tanto, el control delprograma se transfiere (salta) a la primera instrucción después del bucle.



#include <stdio.h>

int main()
{

   int n, a;

   a = 0;
   do
   {
      printf( "Introduzca un numero entero: " );
      scanf( "%d", &n );

      if ( n == 0 )
      {
         printf( "ERROR: El cero no tiene opuesto.\n" );
         break;
         /* En el caso de que n sea un cero,
            el bucle se interrumpe. */
      }
      printf( "El opuesto es: %d\n", -n );
      a += n;
   } while ( n >= -10 && n <= 10 );

   printf( "Suma: %d", a );

   return 0;
}












continue;



La instrucción de salto continue siempre se usa para interrumpir (romper) la ejecución normal de unbucle. Sin embargo, el control del programa no se transfiere a la primera instrucción después del bucle (como sí hace la instrucción break, véase el apartado anterior Instrucción break en C), es decir, el bucle no finaliza, sino que, finaliza la iteración en curso, transfiriéndose el control del programa a la condición de salida del bucle, para decidir si se debe realizar una nueva iteración o no.




#include <stdio.h>

int main()
{

   int n, a;

   a = 0;
   do
   {
     printf( "Introduzca un numero entero: " );
     scanf( "%d", &n );

     if ( n == 0 )
     {
      printf( "ERROR: El cero no tiene opuesto.\n" );
      continue;
      /* En el caso de que n sea un cero,
         la iteración en curso del bucle
         se interrumpe aquí. */
     }
     printf( "El opuesto es: %d\n", -n );
     a += n;
   } while ( n >= -10 && n <= 10 );

   printf( "Suma: %d", a );

   return 0;
}

Parte 1.

Aprenderemos a programar en lenguaje C par empezar.

Que es lenguaje C?

C es un lenguaje de programación creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B, a su vez basado en BCPL.

Al igual que B, es un lenguaje orientado a la implantación de Sistemas Operativos, concreta mente Unix. C es apreciado por la eficiencia del código que produce y es el lenguaje de programación más popular para crear software de sistemas, aunque también se utiliza para crear aplicaciones.

Se trata de un lenguaje de tipos de datos estáticos, débilmente tipificado, de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un control a muy bajo nivel. Los compiladores suelen ofrecer extensiones al lenguaje que posibilitan mezclar código en ensamblador con código C o acceder directamente a memoria o dispositivos periféricos.

Referencia: http://es.wikipedia.org/wiki/C_(lenguaje_de_programaci%C3%B3n)

LINEA DE TIEMPO DEL LENGUAJE C

ESTRUCTURA GENERAL DEL LENGUAJE C.

BIBLIOTECAS
La biblioteca estándar de C (también conocida como libc) es una recopilación de ficheros cabecera y bibliotecas con rutinas, estandarizadas por un comité de la Organización Internacional para la Estandarización (ISO), que implementan operaciones comunes, tales como las de entrada y salida o el manejo de cadenas. A diferencia de otros lenguajes como COBOL, Fortran, o PL/1, C no incluye palabras clave para estas tareas, por lo que prácticamente todo programa implementado en C se basa en la biblioteca estándar para funcionar.

DECLARACIÓN DE VARIABLES

Para proceder a declarar un variable inicialmente se define su tipo ya sea de carácter numero entero o flotante.

para declarar variable numérica entera se declara como seguido de la variable 

para numero entero      int x;

para flotante                 float x;

para carácter                 char "x";

DECLARACIÓN DE CONSTANTES

Para la declaración de constantes solo se necesita escribir la palabra const antes de el nombre de el tipo de variable a declarar mas la asignación de valor

Ejemplo:

const int x=5;

DECLARACIÓN DE FUNCIONES

Inicialmente se define el tipo de variable del cual sera la función se agregan variables entre paréntesis las cuales se utilizaran en nuestra funcion.

#include <stdio.h>

void holamundo(void) /*Esta es la declaracion y a la vez la definicion de la funcion*/

{

  printf("Hola Mundo\n"); /* Esto lo que imprimira nuestra funcion */

return; /* sale de la función */

}

int main(void) /* Función principal del programa */

{

holamundo(); /* llamada a la función holamundo */

return 0; /* sale del programa con código 0 (correcto) */

}

FUNCION MAIN()

int main (void)

{

   esta declaración sera la que contendrá nuestro código y la      

   llamaremos función principal don se rodara todo

   nuestro código se realizaran operaciones y muchas cosas mas e ira entre 

   corchetes

}

COMENTARIOS

Para escribir comentarios solo deberemos poner 2 asteriscos entre 2 diagonales y el comentario que debemos de escribir entre las diagonales y los asteriscos

/*Ingresa aquí tu comentario*/

MACROS

El ANSI C no permite macros que tengan un número variable de argumentos. Pero esta opción fue introducida por varios compiladores y se estandarizó en C99. Las macros variables son particularmente útiles cuando escribimos envolturas para printf. Por ejemplo para mostrar mensajes de advertencia o error.

CONOCIENDO EL ENTORNO DE TRABAJO

Nuestro editor en C sera Dev-C++ 

empezaremos aprendiendo a crear nuevos archivos fuente el cual sera nuestro código con ctrl+n

con este comando crearemos nuevos archivos fuente.

Para compilar nuestro programa necesitaremos presionar la siguiente tecla F9

una vez compilado F10 y para compilar y ejecutar F11

OPERACIONES DE ENTRADA Y DE SALIDA

para dar salida ya sea a datos o caracteres etc se utilizara la función printf

para la entrada de datos al sistema se deberá usar la función scanf

PRINTF

para el printf seguido de la función se deberá agregar dos comillas entre paréntesis y dentro de los paréntesis el mensaje que deseamos dar como en el ejemplo:

printf ("ingrese un numero");

si deseamos ingresar un dato del tipo de variable numérica entera u otra se agregara 

%d para numero entero

%f para numero flotante

%c para un solo carácter tipo letra

%s para una cadena de letras o caracteres

aclaración el por ciento y la especificación de tipo de variable deberá estar dentro de las comillas y en la parte en la cual deseamos aparezca 

ademas de que fuera de las comillas mas no fuera de los paréntesis se pondrá una coma y la variable que deseábamos poner si son mas se deberán poner en orden tal cual como las estamos mandando a escribir y listo  cerraremos con punto y coma

un ejemplo a continuación

printf ("su numero multiplicado:%d",numero);

SCANF

para la función scanf de igual manera se deberá agregar comillas entre paréntesis y dentro de nuestros paréntesis la especificación de la variable que leeremos %d %f %s %c y fuera de paréntesis agregaremos una coma mas un & y la variable en la cual se guardara el valor ingresado la coma y el & son esencialmente necesarios. y nuevamente cerraremos con punto y coma fuera de todo hasta el final de la linea ejemplo a continuación:

       scanf ("%d",&numero);

VARIABLES Y CONSTANTES

Antes que nada una variable es un dato el cual podrá adoptar diferentes valores de su mismo tipo claro a lo largo del transcurso de nuestro código.

Mas una constante sera aquel dato con un valor especifico el cual no podrá cambiar en ningún momento duran el transcurso de nuestro código si desearemos cambiarlo mostraría un mensaje de error

como ya había explicado anterior mente una variable solo se asigna el tipo su nombre y su valor o lo podremos agregar en el transcurso del código con el operador =

ejemplo:

 int x=5;

 const int x=5;

Operadores aritméticos

Estos son los símbolos aritméticos básicos: suma (+), resta (-), multiplicación (*), división (/) y potencia (^).

Este es un ejemplo de cómo usar los operadores aritméticos en TurtleScript:

$sumar = 1 + 1
$restar = 20 - 5
$multiplicar = 15 * 2
$dividir = 30 / 30
$potencia = 2 ^ 2

Los valores resultantes de estas operaciones aritméticos son asignados a variables. Puedes ver los valores resultantes en el inspector.

Si lo que quieres es realizar un cálculo simple, puedes hacer algo como esto:

escribir 2010-12

Ahora veamos un ejemplo con paréntesis:

escribir ( ( 20 - 5 ) * 2 / 30 ) + 1

Primero se calculan las operaciones que están dentro de los paréntesis. En este ejemplo, primero se calcula 20 - 5; el resultado se multiplica por 2, luego se divide por 30 y, por último, se le suma 1. El resultado final es 2. Los paréntesis pueden también usarse en otros casos.

KTurtle también tiene otras funciones aritméticas en forma de órdenes. Echa un vistazo a las siguientes órdenes, eso sí, teniendo en cuenta que se trata de operaciones avanzadas: redondear, aleatorio, raíz, pi, sen, cos, tan, arcsen, arccos, arctan.

Operadores lógicos (verdadero/falso)

Mientras que los operadores aritméticos se usan principalmente con números, los operadores lógicos están pensados para usarse con valores lógicos (verdadero y falso). Hay solo tres operadores lógicos: y, o y no. El siguiente código de TurtleScript muestra cómo usarlos:

verdadero y verdadero  > verdadero
verdadero y falso  > falso
falso y verdadero  > falso
falso y falso  > falso

verdadero o verdadero > verdadero
verdadero o falso  > verdadero
falso o verdadero   verdadero
falso o falso  > falso

no verdadero  > falso
no falso  > verdadero

Puedes ver los valores resultantes en el inspector, aunque también se proporcionan pequeños comentarios al final de las líneas. Y resulta en verdadero solo si ambas partes son verdaderos. O resulta en verdadero si una de las dos partes es verdadero. Y no transforma verdadero en falso y falso en verdadero.

Operadores de comparación

	igual a ==
	no igual a !=
	mayor que >
	menor que <
	mayor o igual que >=
	menor o igual que <=

Expresiones

Una expresión es una combinación de operadores y operandos de cuya evaluación se obtiene un valor. Los operandos pueden ser nombres que denoten objetos variables o constantes, funciones, literales de cualquier tipo adecuado de acuerdo con los operadores u otras expresiones más simples. La evaluación de una expresión da lugar a un valor de algún tipo, una expresión se dice que es del tipo de su resultado. Ejemplos de expresiones:

r=a + 5*b

Precedencia de operadores

La tabla siguiente es una lista que muestra el orden de precedencia y la asociatividad de todos los operadores del lenguaje de programación C++. Están listados de arriba a abajo por orden de precedencia descendente y con la misma descendencia en la misma celda (puede haber varias filas de operadores en la misma celda). La precedencia de los operadores no cambia por la sobrecarga.

Una tabla de precedencias, aunque adecuada, no puede resolver todos los detalles. Por ejemplo, el operador ternario permite expresiones arbitrarias como operador central independientemente de la precedencia del resto de operadores. Así a ? b , c : d es interpretado como a ? (b, c) : d en vez de (a ? b), (c : d).