temarioanacleto2

ELEMENTOS DEL LENGUAJE

 Un programa en C++ es una secuencia de caracteres que se agrupan en componentes léxicos (tokens) que comprenden el vocabulario básico del lenguaje. Estos componentes de léxico son:

**  Palabras reservadas

**  Identificadores

 ** Constantes

 ** Constantes de cadena

 ** Operadores y signos de puntuación.

CARACTERES

Los caracteres que se pueden utilizar para construir elementos del lenguaje (componentes léxicos o tokens) son:

a b c d e f g h i j k l m n o p q r s t u v w x y z

A B C D E F G H I J K L M N O P Q R S T U V W X Y Z

 0 1 2 3 4 5 6 7 8 9

 + - * / = ( ) { } [ ] < > ´ ” ! @ =/ $ ^ & % - : . , ; ? \

 caracteres espacio (blancos y tabulaciones).  

Los identificadores (nombres de variables, constantes, etc.) deben comenzar con una letra del alfabeto (mayúscula o minúscula) o con un carácter subra­yado y pueden tener uno o más caracteres. Los caracteres segundo y posteriores pueden ser letras, dígitos o un subrayado, no permitiéndose caracteres no alfanuméricos ni espacios.

test_prueba                    //legal

X123                             //legal

multi_palabra                  //legal

var25                              //legal

15var                              //no legal

C++ es sensible a las mayúsculas. Las letras mayúsculas y minúsculas se consideran diferentes

Paga_mes es un identificador distinto a paga_mes

Buena práctica de programación aconseja utilizar identificadores significativos que ayudan a documentar un programa.

nombre apellidos salario precio_neto

Edad Longitud Altura Salario_Mes

 PALABRAS RESERVADAS EN C++

Las palabras reservadas o claves no se pueden utilizar como identificadores, debido a su significado estricto en C++; tampoco se pueden redefinir. 

asm* default for new* sizeof typedef

auto delete* friend* operator* static typename

bool* do goto private* struct unión

break double if protected* switch unsigned

case else inline* public* template* using

catch* enum int register this* virtual*

char explicit* long return throw* void

class* extern mutable* short true* volatile*

const false* namespace* signed try* while

continue float

* Estas palabras no existen en C ANSI

Los diferentes compiladores comerciales de C++ pueden incluirademás, nuevas palabras reservadas. Estos son los casos de Borland, Microsoft y Symantec.

CONSTANTES C++

contiene constantes para cada tipo de dato simple (integer, char, etcétera). Las constantes pueden tener tres sufijos, u, l y f, que indican tipos unsigned, long y float, respectivamente. Asimismo, se pueden añadir los prefijos o y ox que representan constantes octales y hexadecimales.

 456 0456 Ox456               //constantes enteras: decimal, octal,hexadecimal

 1231 123ul                        //constantes enteras: long, unsigned,long

 'B' 'b' '4'                            //constantes tipo char

 3.1415f 3.14159L            //constantes reales de diferente posición

“cadena de caracteres”      //constante de cadena

Las cadenas de caracteres se encierran entre comillas, y las constantes de un solo carácter se encierran entre comillas simples.

 “ ”                                    //cadena vacía, '\0'

 Una constante literal es un valor escrito directamente en el programa siempre que se necesite. Por ejemplo,

int miEdad = 25;

miEdad es una variable de tipo int; 25 es una constante literal.

 CONSTANTES DE PROGRAMACION.

¿Que es una variable?

una variable es un espacio en la memoria, en el cual el programador asigna un valor determinado por el tipo de dato que el lenguaje de programación va soportar, para declararla es necesario saber que tipo de dato la contiene.

es representada por un nombre que es asignado por el programador, y se nombra justo después de su tipo de dato, los siguientes son los tipos de datos esenciales:

int; es numérico sirve para números enteros sin punto decimal  (1,2,3,4.. )

float; es numérico y sirve para números con parte fraccionaria, es decir con punto decimal ( 1.2, 1.3, 1.4, ….)

char; es de tipo carácter y cadena de caracteres, es decir que puedes asignar desde una letra, símbolo o numero hasta una palabra o serie de caracteres ( a, 2, !, &, hola, etc.)

bool; es de tipo verdadero o falso, este tipo de dato mostrara en pantalla un “1” en caso de ser true o “0” en caso de ser false.

Como declarar una variable en lenguaje de programación C++

primero como ya dijimos antes se especifica el tipo de dato, después se nombra, y si se asigna un valor debe ir después de un signo de igualdad (” = “) , si se van a declarar varias variables solo se separan con comas (” , “) dentro de la misma linea del tipo de dato especificado y al finalizar escribir punto y coma (” ; “). ejemplos:

Ejemplos de asignación de contenidos son estos:

¿Qué  es  un  OPERADOR?

 “Un operador es un elemento de programa que se aplica a uno o varios operandos en una expresión o instrucción. Los operadores que requieren un operando, como el operador de incremento se conocen como operadores unarios.

Los operadores que requieren dos operandos, como los operadores aritméticos (+,-,*,/) se conocen como operadores binarios. Un operador, el operador condicional (?:), utiliza tres operandos y es el único operador ternario de C++” .

Existen 6 tipos de operadores según sufunción, que son aritméticos, relacionales, deasignación, lógicos, de dirección y demanejo de Bits.
 

 OPERADORES  DE  ASIGNACIÓN

“Tal  y  como  su  nombre  lo  indica,  este  tipo  de  operadores  permiten  la  asignación  de  un  valor especifico a una variable. En C++se encuentran disponibles los siguientes operadores:

Todos ellos son operadores binarios, de los cuales,  “=”  es el único de asignación simple, los demás  son operadores de asignación compuestos, puesto que están conformados por más de un símbolo, por ejemplo “+=” se compone  del operador  “+“ y el operador “=“.

Los seis primeros aceptan operandos de distinto tipo, mientras que los cinco últimos: <<=, >>=, &=, ^=  y |=, implican manejo de bits, por lo que sus operandos deben ser numero int en sus distintas variantes. El funcionamiento de estos operadores se encuentra descrito en la sección de operadores de bits.

La parte izquierda (que tiene que ser una variable no constante) adquiere el valor señalado en la expresión de la derecha, pero se mantiene el tipo original de la variable de la parte izquierda. En caso necesario  se realiza una conversión de tipo (con pérdida de precisión en su caso) del izquierdo al derecho.

Es necesario resaltar que el operador C++ de asignación simple (=) se distingue de otros lenguajes como Pascal que utilizan el símbolo := para este operador. Observe también que la asignación simple (=)  utiliza  un  símbolo  distinto  del  operador  relacional  de  igualdad  (==)”. Además,  en  los operadores compuesto no debe haber espacios de la forma “+=” y que el igual siempre va a la derecha del resto de operandos.

OPERADORES ARITMÉTICOS

La operación modulo corresponde a obtener el residuo de la división, de modo que al dividir 5 entre 2 tendremos como resultado 2 y como residuo 1, por tanto 5 % 2 corresponde al 1 que sobra de la división exacta.

Es necesario hacer una observación acerca de los operadores de incremento y decremento, ya que dependiendo de su ubicación con respecto a la variable, se tienen acciones diferentes. Si el operador precede a la variable, se conoce como pre-incremento o pre-decremento y se dice que el operador está en su forma prefija. Por el contrario, si el operador esposterior a la variable se encuentra en la forma posfija y se lel lama pos-incremento o pos-decremento según el caso.

“Cuando  un operador  de incremento o  decremento  precede  a su  variable, se  llevará a  cabo  la operación de incremento o de decremento antes de utilizar el valor del operando”, tal y como se muestra en el siguiente ejemplo:

En el caso de los post-incrementos y post-decrementos pasa lo contrario: se utilizará el valor actual del operando y luego se efectuará la operación de incremento o decremento”.

Tal y como se presentó anteriormente, también existen o peradores para los punteros, sin embargo  estos solo aplican para aquellos apuntadores a matrices, arreglos o listas de elementos, y aunque se muestran a continuación, se explicaran de una mejor forma en el material de apuntadores opunteros en c++.

OPERADORES RELACIONALES

“Los operadores relacionales, también denominados operadores binarios lógicos y de comparación, se utilizan para comprobar la veracidad o falsedad de determinadas propuestas de relación (en realidad  se  trata  respuestas a preguntas). Las expresiones que los contienen se denominan expresiones relacionales. Aceptan diversos tipos de argumentos, y el resultado, que es la respuesta a la pregunta, es siempre del tipo cierto/falso, es decir, producen  un resultado booleano.

Si la propuesta es cierta, el resultado es true (un valor distinto de cero), si es falsa será false (cero). C++ dispone de los siguientes operadores relacionales:

Como puede verse, todos ellos son operadores binarios (utilizan dos operandos), de los cuales, dos de ellos son de igualdad :== y !=, y sirven para verificar la igualdad o desigualdad entre valores aritméticos o punteros.   Estos dos operadores pueden comparar ciertos tipos de punteros, mientras que el resto de los operadores relacionales no pueden utilizarse con ellos.

Cualquiera que sea el tipo de los operandos, por definición, un operador relacional, produce un bool (true o false) como resultado, aunque en determinadas circunstancias puede producirse una conversión  automática de tipo a valores int (1 si la expresiónes cierta y 0 si es falsa).

En las expresiones relacionales E1 <operador> E2,  los operandos deben cumplir alguna de las condiciones siguientes: 

·    E1 y E2 son tipos aritméticos.

·    E1 y E2 son punteros a versiones cualificadas o no cualificadas de tipos compatibles.

·    Uno de ellos es un puntero a un objeto, mientras que el otro es un puntero a una versión  cualificada o no cualificada de void.

·    Uno de los dos es un puntero, mientras que el otro es un puntero nulo constante.

OPERADORES LÓGICOS

“Los operadores lógicos  producen un resultado booleano, y sus operandos son también valores  lógicos o asimilables a ellos (los valores numéricos son asimilados acierto o falso según su valor sea cero o distinto de cero). Por el contrario, las operaciones entre bits producen valores arbitrarios.

 Los operadores lógicos son tres, dos de ellos son binarios y el último (negación) es unario:

 AND lógico

Devuelve un valor lógico true si ambos operandos son ciertos. En caso contrario el resultado es false. La operatoria es como sigue: El primer operando (de la izquierda) es convertido a bool. Para ello, si es una expresión, se evalúa para obtener el resultado (esta computación puede tener ciertos efectos  laterales). A continuación, el valor obtenido es convertido a bool cierto/falso siguiendo las reglas de conversión estándar.Si el resultado es false, el proceso se detiene y este es el resultado,sin que en este caso sea necesario evaluar la expresión de la derecha (recuérdese que en el diseño de C++ prima la velocidad).

Si el resultado del operando izquierdo es cierto, se continúa con la evaluación de la expresión de la derecha, que también es convertida a bool. Si el nuevo resultado es true,entonces el resultado del operador es true. En caso contrario el resultado es false.

El valor m,que es interpretado como un puntero al primer elemento de la matriz, es transformado a un bool. Como es distinto de cero (no es un puntero nulo) el resultado es cierto. A continuación, el valor x es convertido también a bool. En este caso la conversión produce falso, con lo que este es el resultado del paréntesis de la sentencia if”.

 OR Lógico

Este operador binario devuelve true si alguno de los operandos es cierto.  En caso contrario devuelve false. Este operador sigue un funcionamiento análogo al anterior. El primer operando (izquierdo) es convertido  a  bool.  Para  ello,  si  es  una  expresión,  se  evalúa  para  obtener  el  resultado  (esta computación puede tener ciertos efectos laterales). Acontinuación el valor obtenido es convertido a bool cierto/falso siguiendo las reglas de conversión  estándar. Si el resultado es true, el proceso se detiene y este es el resultado, sin que en este caso sea necesario evaluar la expresión de la derecha (recuérdese que en el diseño de C++ prima la velocidad).

Si el resultado del operando izquierdo es false, se continúa con la evaluación de la expresión de la derecha, que también es convertida a bool. Si el nuevo resultado es true, entonces el resultado del operador es true. En caso contrario el resultado es false.

  Negación Lógica

Este operador es denominado también No lógico y se representa en el texto escrito por la palabra inglesa NOT (otros  lenguajes utilizan directamente esta palabra para representar el operador en el código). El operando (que puede ser una expresión que se evalúa a un resultado) es convertido a tipo bool, con lo que solo puede ser uno de los valores cierto/falso. Acontinuación el operador cambia su valor; Si es cierto es convertido a falso y viceversa.

Resulta por tanto, que el resultado de este operador es siempre un tipo bool, aunque al existir una conversión estándar por la que un cero es convertido a false, y cualquier valor distinto de cero a true, coloquialmente  se dice que este operador convierte un operando 0 en 1 y uno no-cero en 0. En otras palabras: este operador devuelve cierto (true) sila expresión se evalúa a distinto de cero,en caso contrario devuelve falso (false).
Si “E” es una expresión, “!E” es equivalente a “(0==E)”. Como consecuencia, las expresiones que siguen son equivalentes dos a dos:

STDIO.H

 Que significa "estándar entrada / salida " encabezado, es la encabezamiento en el C biblioteca estándar que contiene macro definiciones, constantes, y las declaraciones de funciones y tipos usados para la entrada de varios estándar y operaciones de salida. La funcionalidad que desciende de un "portátil / paquete de O ", escrita por Mike Leks en los Laboratorios Bell en la década de 1970. C + +, por razones de compatibilidad, incluye stdio.h así como un encabezado equivalentes en lo esencial, stdio, Que declara la stdio.h funciones y tipos dentro de la std espacio de nombres.

Las funciones declaradas en stdio.h son muy populares, ya que como parte de la biblioteca estándar de C, Se garantiza que funcione en cualquier plataforma que soporte aplicaciones de C. sobre una plataforma en particular puede , sin embargo, tienen razones para usar la plataforma de I / O rutinas , en lugar de la stdio.h rutinas.

Los programadores tienen que incluir la stdio.h cabecera en el código fuente para poder usar las funciones declaradas en el mismo:

Ejemplo:

 
# Include <stdio.h>
          Int principal (vacío)
          {
                   Int ch;
                   Mientras que ((ch = getchar ())! = FEO)
                              putchar (ch);
                              putchar ('\ n');
                              Volver 0;
          }

 conio.h

Es una C archivo de cabecera utilizado en la antigua MS- DOS compiladores para crear interfaces de usuario de texto. No se describe enEl lenguaje de programación C libro, y no es parte de la librería estándar de C, ISO C ni es requerido por POSIX.

Este encabezado declara varias funciones útiles para realizar la colección de " consola de entrada y salida "de un programa. La mayoría de los compiladores de C que se dirigen a DOS, Windows 3.x, Phar Lap, Dosx, OS / 2O Win3 tienen esta cabecera y el suministro de las funciones de librería asociada en la librería de C por defecto. La mayoría de los compiladores de C que se dirigen a UNIX y Linux No cuentan con el encabezado y no proporcionan las funciones de librería.

Funciones miembro

Cómo usar #include en C y C++

 La directiva de preprocesador #include se usa en los lenguajes C y C++para “incluir” las declaraciones de otro fichero en la compilación. Esta directiva no tiene más misterio para proyectos pequeños. En cambio, puede ayudar aprovechar bien esta directiva en proyectos con un gran número de subdirectorios.

El efecto de #include

Cuando el preprocesador encuentra una línea #include "fichero", entonces reemplaza esta línea por el fichero incluido. Así procede con todas las directivas de inclusión – también en aquellas anidadas en los fichero ya a su vez incluidos. Es decir, existe un sólo fichero grande tras la precompilación.

No obstante, esta unión de varios ficheros no tiene lugar físicamente. Lo que sucede es que se interrumpe la compilación del fichero actual, se compila el fichero incluido y, tras compilarlo, se continúa con el primero. Por eso, el compilador puede decirnos, en qué fichero tuvo lugar un error de compilación.

En cambio, conviene tener esta idea del fichero único en mente, porque a veces ayuda a encontrar errores. Uno muy típico es olvidarse el punto y coma tras la declaración de una clase.

En este caso hay una declaración de clase en el fichero incluido:

Lo habitual es posicionar las inclusiones al inicio de cada fichero. Esto tiene sentido, porque se suele requerir declaraciones básices antes de declarar clases más complejas. Mi lugar preferido en los ficheros de cabecera es tras el guardián de inclusión múltiple.

Así se evita que un compilador poco sofisticado abre otra vez el mismo conjunto de ficheros cuando se inluye un fichero de cabecera dos o más veces.

En los ficheros de definición (los .c o .cpp), los guardianes de inclusión múltiple no hacen falta. No obstante, puede haber una restricción importante cuando se usan cabeceras precompiladas. En este caso, todos los ficheros fuente deben incluir primero el mismo fichero de cabecera – que es aquello que define la cabecera precompilada. El compilador de C++ de Borland permite varios ficheros de cabecera para la definición de una cabecera precompilada. Estas inclusiones deben ser lor primeros ficheros incluidos y se deben incluir en el mismo orden.

Puede darse el caso de no poner las inclusiones en el inicio de un fichero. Esto es frecuente en los fichero que se podrían denominar “programados en directivas de precompilación”. Normalmente se trata de ficheros de cabeceras con definiciones muy básicas como ajustes a la plataforma empleada. Por ejemplo, en medio de un fichero “definiciones_basicas.h” puede haber unas líneas

La directiva #include existe en dos versiones. En una se pone el nombre de fichero entre comillas, en la otra entre paréntesis angulares (el signo menor y mayor como “comillas”).

La versión con los paréntesis angulares busca los ficheros en todos los directorios que se han especificado en la llamada al compilador – normalmente con la opción “-I”. Estos directorios se suelen rastrear por el fichero incluido en el orden en que aparecen en la línea de comando.

Cuando se incluye un fichero entre comillas, entonces el compilador busca este fichero primero en el mismo directorio que el fichero actualemente compilado y después en los demás directorios. Es decir, la versión con comillas se diferencia de la versión con paréntesis angulares únicamente por buscar primero en el directorio del fichero compilado. Tras no encontrarlo ahí actúa igual.

Esto muchas veces no es ninguna diferencia, ya que se suelen especificar todos los directorios en la línea de comando del compilador. Así no se suele dar el caso que se puede incluir un fichero con comillas pero no con paréntesis angulares.

Más significativo es el comportamiento ante ficheros con el mismo nombre en distintos directorios. En este caso la versión con comillas da preferencia sobre el fichero en el mismo directorio y esto suele ser el mejor acertado. Aunque sea preferible nombrar ficheros de forma única en un proyecto, es posible que no se pueda evitar tener dos ficheros con el mismo nombre cuando se incluyen varias bibliotecas de terceros.

De ahí se puede deducir que es imperativo incluir cabeceras de la misma biblioteca con comillas. De esta forma se puede asegurar que las cabeceras de una biblioteca se incluyan entre si aunque haya otros con el mismo nombre en uno de los directorios especificados en la línea de comandos.

Además, incluir con comillas puede dar al programador un significado adicional: que este fichero está bajo la custodia de mi equipo de desarrollo. Las cabeceras incluidas con paréntesis angulares son de bibliotecas de terceros. Los primeros ficheros puedo modificar si hace falta, los segundos no.

El orden de las inclusiones

El orden de las directivas #include no importa cuando todos los identificadores del programa son únicos. No obstante, a veces no lo son yconviene generar el error “este identificador ya existe” en nuestro código y no en el código de una biblioteca estándar.

Esto se consigue incluyendo primero las caberas de terceros. Si aparece un error de identificador doble, entonces aparece en la segunda definición – que es la nuestra – y ahí podemos cambiar el nombre del objeto sin problema.

En proyectos realmente grandes puede haber varias bibliotecas de distintas dependencias. Por la misma razón de generar los errores de identificadores dobles en el código más fácilmente modificable, conviene incluir las bibliotecas más básicas primero. Dentro del mismo nivel podemos ordenar los ficheros incluidos de forma alfabética. Esto ayuda a encontrar inclusiones que faltan o sobran.

El siguiente código muestra una secuencia de inclusiones para un fichero “definicion_de_mi_clase.cpp”.

VARIABLES Y TIPOS DE DATOS.

 Una variable es un espacio de memor´ıa reservado en el ordenador para contener valores que pueden cambiar   durante la ejecucio´n  de un programa. Los tipos  que se le asignen  a estas determinan co´mo se manipular´a la informaci´on contenida en ellas.

 Cada  variable  necesita un identificador que la distingue de las dema´s. Un identificador v´alido es una secuencia de una o m´as letras, d´ıgitos o guiones bajos, recordando que no deben coincidir con palabras reservadas   del lenguaje, deben comenzar por una letra y adem´as tomar en cuenta que C++ hace diferencia entre mayu´sculas y minu´sculas.

 Las variables  que se pueden  presentar en un programa  son de los siguientes tipos:

 1.Variables Locales. Se definen solo en bloque en el que se vayan  a ocupar, de esta manera evitamos tener variables  definidas que luego no se utilizan.

 2.Variables Globales. No son lo m´as recomendable, pues su existencia atenta contra la comprensio´n del coodigo y su encapsulamiento.

 3.  Variables Est´aticas. Se tienen que inicializar  en el momento en que se declaran,  de manera  obligatoria.

 Ahora hablemos de los tipos de datos que reconoce C++. Estos definen el modo en que se usa el espacio (memoria)   en los programas. Al especificar un tipo de datos, estamos indicando al compilador   como crear un espacio de almacenamiento en particular, y tambi´en como manipular este espacio. Un tipo de dato define el posible rango de valores que una variable  puede tomar al momento de ejecucio´n del programa  y a  lo largo de toda la vida u´til  del propio programa.

 Los tipos de datos pueden  ser predefinidos o abstractos. Un tipo de dato predefinido es intr´ınsecamente comprendido por el compilador.  En contraste, un tipo de datos definido por el usuario es aquel que usted o cualquier  otro programador crea como una  clase, que comu´nmente son llamados  tipos de datos abstractos.

  Los tipos de datos m´as comunes en C++ son: