INSTITUTO TECNOLOGICO SUPERIOR

DE CALKINI EN EL ESTADO DE
CAMPECHE

PRCTICA NO. 7 ENTORNO DE UN

LENGUAJE DE PROGRAMACION
 NDICE

NDICE ............................................................................................................... 2
INTRODUCCIN ............................................................................................... 3
ESTRUCTURA BSICA DEL LENGUAJE C++ ................................................ 4
Tipos primitivos: ..................................................................................... 8
Tipo lgico ................................................................................................. 9
Tipo carcter extendido ............................................................................ 9
Literales y constantes: .......................................................................... 10
Uso de #define para declarar constantes en C++: ............................... 11
Uso de const para declarar constantes en C++ ................................... 12
Identificadores: ........................................................................................... 12
Parmetros y Argumentos del lenguaje C++ ............................................ 13
Tipos de parmetros: .............................................................................. 14
Parmetros por valor: ............................................................................. 14
Parmetros por referencia: .................................................................... 15
Operadores.................................................................................................. 16
Operadores de asignacin: .................................................................... 16
Operadores aritmticos .......................................................................... 17
Operadores relacionales: ....................................................................... 17
Operadores lgicos: ............................................................................... 18
Operadores de bits: ................................................................................ 19
Operadores de direccin: ....................................................................... 20
Entrada y salida C++ .................................................................................. 20
CONCLUSIN ................................................................................................. 24
BIBLIOGRAFA ............................................................................................... 25
REFERENCIA ELECTRNICA ....................................................................... 25
 INTRODUCCIN

En este respectivo trabajo de investigacin se implementar todo lo que

respecte al lenguaje C++ tal como su estructura, impartiendo todos sus
elementos el cual son indispensables al momento de programar en este
lenguaje.
Dichos elementos son las funciones con su respectiva estructura, los tipos de
datos, las variables, las constantes en sus dos tipos, los operadores, los
identificadores, las entradas y salidas, etc.
Despus de haber explicado toda la integracin de esta correspondiente
investigacin, es importante partir sobre el programa, el cual puedo decir que no
es nada ms que una serie de instrucciones dadas al ordenador en un lenguaje
entendido por l, para decirle exactamente lo que queremos que haga. Si el
ordenador no entiende alguna instruccin, lo comunicar generalmente mediante
mensajes visualizados en la pantalla.
Para traducir un programa escrito en un determinado lenguaje de programacin
a lenguaje mquina (cdigo binario), se utiliza un programa llamado compilador
que ejecutamos mediante el propio ordenador. Este programa tomar como
datos nuestro programa escrito en un lenguaje de alto nivel, por ejemplo en C++,
y dar como resultado el mismo programa pero escrito en lenguaje mquina,
lenguaje que entiende el ordenador.
Respectando al lenguaje C++ es su independencia de la plataforma en lo que a
cdigo fuente se refiere. Otra caracterstica importante de C++ es que es un
lenguaje que soporta diversos estilos de programacin (por ejemplo, la
programacin genrica y la programacin orientada a objetos (POO).
Todos estos estilos se basan en una verificacin fuerte de tipos y permiten
alcanzar un alto nivel de abstraccin.
Despus de implementar lo anterior, es posible proceder al respectivo desarrollo
de esta investigacin.
ESTRUCTURA BSICA DEL LENGUAJE C++
C++ es un lenguaje de programacin orientado a objetos hbrido. Esto quiere
decir que permite realizar programas estructurados sin la orientacin a objetos y
programas orientados a objetos.
Los compiladores de C++ proporcionan bibliotecas de funciones.
Cada biblioteca de funciones tiene asociada un archivo de definicin que se
denomina cabecera.
Para utilizar algo de una biblioteca en un programa, hay que colocar al principio
del programa una directiva de pre procesamiento seguida de la cabecera de la
biblioteca entre ngulos.
La estructura general de un programa C++ es la siguiente:
Comentarios
Directivas del preprocesador
Declaracin de variables globales y funciones
Int main ( ) // Funcin principal main
{
Declaraciones locales de la funcin principal
Instrucciones de la funcin principal
}
Otras funciones:
funcion1 (.....)
{
Declaraciones locales de la funcin 1
Instrucciones de la funcin 1
}
funcion2 (.....)
{
Declaraciones locales de la funcin 2
Instrucciones de la funcin 2
}
.....
Por ejemplo:
// Programa que muestra el mensaje Hola mundo!!! Por pantalla
#include <iostream>
Using namespace std;
Int main (void)
{
Cout << "Hola mundo!!!\n";
Return 0;
}
Vamos a comentar cada una de las partes del programa anterior:
// Programa que muestra el mensaje Hola mundo!!! Por pantalla
Esta lnea es un comentario.
Todas las lneas que comienzan con dos barras (//) se consideran comentarios
y no tienen ningn efecto sobre el comportamiento del programa.
Los comentarios tambin pueden ir entre los smbolos /* y */. En ese caso
pueden ocupar ms de una lnea.
#include <iostream>
Esta lnea es una directiva del preprocesador.
Todas las lneas que comienzan con el smbolo # son directivas para el
preprocesador.
La directiva #include, sirve para insertar ficheros externos dentro de nuestro
programa. Estos ficheros son conocidos como ficheros incluidos, ficheros de
cabecera o headers.
En este caso, la directiva #include <iostream> indica al preprocesador que en
este programa se debe incluir el archivo iostream. El cdigo fuente no cambia,
pero el compilador ve el fichero incluido.
Iostream es la librera de entrada/salida de C++. Si no se incluye esta librera no
podemos utilizar la instruccin cout para imprimir un mensaje por pantalla.
La inclusin de ficheros la podemos realizar de dos formas:
# Include
# define
El directorio Include, es posible su uso en cualquiera de las dos formas:
#include <nombre de fichero cabecera>
#include "nombre de fichero de cabecera"
En el primer caso el preprocesador buscar en los directorios include definidos
en el compilador.
En el segundo, se buscar primero en el directorio actual, es decir, en el que se
encuentre el fichero fuente, si no existe en ese directorio, se buscar en los
directorios include definidos en el compilador. Si se proporciona el camino como
parte del nombre de fichero, slo se buscar en el directorio especificado.
Existen archivos de cabecera estndar muy utilizados:

El uso ms frecuente en C++ de las directivas del preprocesador es la inclusin

de archivos de cabecera, pero tambin se usan para definir macros, nombres de
constantes, etc.
Using namespace std;
En grandes proyectos formados por varios archivos, es posible que en archivos
diferentes del mismo proyecto se encuentren recursos con el mismo nombre.
Para evitar confusiones y saber a qu recurso estamos haciendo referencia se
utilizan los espacios de nombres (namespace).
Un espacio de nombres es bsicamente un conjunto de nombres de recursos
(clases, mtodos, funciones, etc) en el cual todos los nombres son nicos.
Todos los elementos de la biblioteca estndar de C++ se declaran dentro de un
espacio de nombres llamado std.
Con la instruccin using namespace std estamos indicando que vamos a usar
este espacio de nombres.
Esta lnea se incluir en la mayora de programas que escribamos en C++.
Si no la escribimos, la instruccin cout << "Hola mundo!!!\n"; tendramos que
escribirla indicando el espacio de nombres donde se declara cout as:
std::cout<<Hola mundo!!!\n;
Int main (void)
Un programa en C++ no orientado a objetos est formado bsicamente por una
o varias funciones.
La funcin main es la funcin principal del programa.
La funcin principal es el punto de inicio del programa. Si el programa contiene
varias funciones, la ejecucin del mismo comienza por la funcin main.
Todo programa escrito en C++ debe contener una funcin main.
Las llaves { } indican donde empiezan y donde acaban las instrucciones de la
funcin.
Cout << "Hola mundo!!!\n";
Esta lnea muestra por pantalla Hola mundo!!! Y un salto de lnea.
Cout es un objeto que se declara en el archivo iostream en el espacio de nombres
std, por eso tenemos que incluir ese archivo al principio del programa y declarar
que vamos a utilizar ese espacio de nombres.
La instruccin acaba con punto y coma.
El punto y coma se utiliza para indicar el final de una instruccin y sirve para
separarla de instrucciones posteriores.

Despus de saber la estructura bsica de un ejemplo del programa elaborado en

lenguaje C++, a continuacin se respectarn a especificar los distintos
elementos que pueden ser usados, muy tiles en otros ejemplos ms complejos
que el anterior.

Tipos de datos:
Para representar los tipos de datos, es necesario ejemplificar una operacin
Aritmtica:
Dato1 = 20;
Dato2= 10;
Resultado = Dato1 + Dato2;
Para que el compilador C++ reconozca esta operacin es necesario especificar
previamente el tipo de cada uno de los operandos que intervienen en la misma,
as como el tipo de resultado. Para ello, escribiremos una lnea como la siguiente:
Int Dato1, Datos2, Resultado;
Dato1 = 20;
Dato2= 10;
Resultado = Dato1 + Dato2;
La declaracin anterior le indica al compilador C++ que Dato1, Dato2 y Resultado
son de tipo entero (Int). Observe que se puede declarar ms de una variable del
mismo tipo utilizando una lista separada por comas.
Los tipos de datos en C++ se clasifican en: tipos primitivos y tipos derivados. La
razn para ofrecer ms de un tipo de datos es permitir al programador
aprovechar las caractersticas del Hardware, ya que diferentes mquinas pueden
presentar diferencias significativas en los requerimientos de memoria, tiempo de
acceso a memoria y velocidad de clculo entre los distintos tipos.

Tipos primitivos:

Numricos enteros
El tipo de dato numrico entero es un subconjunto finito de los nmeros enteros del
mundo real. Pueden ser positivos o negativos.
En C++ los tipos de datos numricos enteros son los siguientes:

Tipo de Descripcin Nmero de Rango

Dato bytes tpico
short Entero corto 2 -32768 a 32767

int Entero 4 -2147483648

a +2147483647
long Entero largo 4 -2147483648
a +2147483647
char Carcter 1 -128 a 127

Con los tipos enteros pueden utilizarse los calificadores signed y unsigned.
Estos calificadores indican si el nmero tiene signo o no. Si se usan solos, sin
indicar el tipo de dato se asume int.
Por ejemplo, las siguientes declaraciones son equivalentes:
Unsigned int x; equivale a: unsigned x;
Usando estos calificadores podemos tener los siguientes tipos enteros:

Tipo de Descripcin Nmero Rango

Dato de bytes
tpico
signed Entero corto 2 -32768 a 32767
short
unsigned Entero corto sin 2 0 a 65535
short signo
signed int Entero 4 -2147483648 a +2147483647

unsigned Entero sin signo 4 0 a 4294967295

int
signed long Entero largo 4 -2147483648 a +2147483647

unsigned Entero largo sin 4 0 a 4294967295

long signo
 signed char Carcter 1 -128 a 127

unsigned Carcter sin signo 1 0 a 255

char
Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros
sin utilizar el calificador:
signed int a; es equivalente a escribir int a;

Tipos de datos numricos reales

El tipo de dato numrico real es un subconjunto finito de los nmeros reales.
Pueden ser positivos o negativos.
En C++ los tipos de datos numricos reales son los siguientes:

Tipo Descripcin Nmero Rango

de de bytes
Dato tpico
float Real (Nmero en 4 Positivos: 3.4E-38 a 3.4E38
coma flotante) Negativos: -3.4E-38 a -3.4E38
double Real doble(Nmero 8 Positivos: 1.7E-308 a 1.7E308
en coma flotante de Negativos: -1.7E-308 a -1.7E308
doble precisin)
long Real doble largo 10 Positivos: 3.4E-4932 a 1.1E4932
double Negativos: -3.4E-4932 a -
1.1E4932

Tipo lgico
Los datos de este tipo slo pueden contener dos valores: true o false (verdadero
o falso).
Si se muestran como enteros, el valor true toma el valor 1 y false el valor 0.

Tipo Descripcin Nmero Rango

de de bytes
Dato tpico
bool Dato de tipo lgico 1 0, 1

Tipo carcter extendido

Este tipo se utiliza para representar caracteres UNICODE. Utiliza 2 bytes a
diferencia del tipo char que solo utiliza 1.
 Tipo de Descripcin Nmero Rango
Dato de bytes
tpico
wchar_t Carcter Unicode 2 0 a 65535

Variable:
En programacin, una variable es un espacio de memoria reservado para
almacenar un valor que corresponde a un tipo de dato soportado por el lenguaje
de programacin. Una variable es representada y usada a travs de una etiqueta
(un nombre) que le asigna un programador o que ya viene predefinida.
Es recomendable que una variable no puede tener espacios, caracteres
especiales (acentos, signos), tiene que empezar con una letra.
Como declarar una variable en C++:
C++ maneja varios tipos de variables: numricas, de caracteres y boolean (cierto
o falso) esencialmente.
Para declarar una variable numrica llamada peso que inicie con un valor de 0,
escribimos esto: int peso=0;
Para declarar una variable numrica llamada distancia que inicie con un valor de
2.67, escribimos esto: float distancia=2.67;
Para declarar una variable de carcter llamada inicial, con un valor de R,
escribimos esto: char inicial=R;
Para declarar una variable boolean llamada terminado, que empiece como falso,
escribimos esto: bool terminado=false;
Las variables que podemos declarar en C++; son las siguientes:
Para variables numricas sin decimales se usa: int
Para variables numricas con decimales se usa: float
Para variables de un solo caracter se usa: char
Para variables boolean se usa: bool
Como declarar varias variables en C++:
Solo se pone el tipo de dato (int, float, char, bool) y separamos las variables con
comas.
Int num=0, peso=16, altura=10;
Siempre va un punto y coma (;) al final de la declaracin de variables

Literales y constantes:
Las datos constantes, mal llamadas por algunos "variables constantes"
(realmente no son variables) tienen un valor fijo durante toda la ejecucin del
programa, es decir, este valor no cambia ni puede ser cambiado a lo largo de la
ejecucin de nuestro programa. Las constantes son muy tiles para especificar
el tamao de un vector y para algunas otras cosas, como facilidad de uso y
confiabilidad del cdigo. Para declarar una constante, se hace despus de
declarar las libreras y antes de las funciones, la sintaxis es la siguiente: #define
nombre_constante valor. Veamos algunos detalles y luego unos ejemplos
sencillos del uso de las constantes en C++
En C++ se pueden definir constantes de dos formas, ambas vlidas para
nosotros. La primera es por medio del comando #define nombre_ constante valor
y la segunda es usando la palabra clave const, siendo permitidos los datos
mostrados en el ttulo Tipos de datos de esta respectiva investigacin.

Uso de #define para declarar constantes en C++:

La instruccin #define nos permite declarar constantes (y algunas cosas ms) de
una manera rpida y sencilla. Hay que tener en cuenta que al declarar constantes
con #define debemos hacerlo despues de los #include para importar libreras
pero antes de declarar nuestras funciones y dems. Veamos un ejemplo:
Ejemplo de uso de #define en C++ para declarar constantes

Notemos que ha sido bastante fcil, sin embargo no todo es bueno. Realmente
al usar la instruccin #define en C++ no estmos creando una constante
realmente, estamos creando una expresin y por tal motivo hay algunas cosas
que se complican, veamos:
Si intentamos ejecutar el cdigo anterior obtendremos un error al haber usado el
operador << justo despues de PI, esto sucede porque PI no es tratado
exactamente como una variable cualquiera sino como una expresin, as que
realmente aunque podemos usar #define para declarar constantes no es la mejor
opcin.
Veamos ahora cual es realmente la forma ms adecuada de declarar constantes
en C++, esto se hace por medio de la instruccin const, veamos:
Uso de const para declarar constantes en C++
La instruccin const nos permite declarar constantes de una manera ms
adecuada y acorde. Las constantes declaradas con const poseen un tipo de dato
asociado (como debera ser siempre) y se declaran al interior de nuestro cdigo
como un tipo cualquiera. Veamos un ejemplo:
Ejemplo de uso de const en C++ para declarar constantes:

Notemos que de igual forma ha sido bastante fcil y mejor an ha sido mucho
ms intuitivo y sencillo para nosotros. Se puede ver que la declaracin es muy
similar a la de una variable cualquiera y que ya no tenemos complicaciones al
intentar aadir la instruccin endl para agregar el salto de lnea. Veamos que
realmente la variable no puede cambiar:

Si intentamos ejecutar el cdigo anterior obtendremos un error al intentar

cambiarle el valor a PI, pues lo hemos definido como una constante y el lenguaje
no nos permitir cambiarle en ningn momento el valor.

Identificadores:
Un identificador es un conjunto de caracteres alfanumricos de cualquier longitud
que sirve para identificar las entidades del programa (clases, funciones,
variables, tipos compuestos) Los identificadores pueden ser combinaciones de
letras y nmeros. Cada lenguaje tiene sus propias reglas que definen como
pueden estar construidos. Cuando un identificador se asocia a una entidad
concreta, entonces es el nombre de dicha entidad, y en adelante la representa
en el programa. Nombrar las entidades hace posible referirse a las mismas, lo
cual es esencial para cualquier tipo de procesamiento simblico.
Restricciones de la composicin de los identificadores en C++
Solo hay dos restricciones en cuanto a la composicin:
El primer carcter debe ser una letra o el guin bajo. El Estndar establece
que los identificadores comenzando con guin bajo y mayscula no deben
ser utilizados. Este tipo de nombres se reserva para los compiladores y
las Libreras Estndar. Tampoco se permite la utilizacin de nombres que
contengan dos guiones bajos seguidos.
El estndar ANSI establece que como mnimo sern significativos los 31
primeros caracteres, aunque pueden ser ms, segn la implementacin.
Es decir, para que un compilador se adhiera al estndar ANSI, debe
considerar como significativos, al menos, los 31 primeros caracteres.

Parmetros y Argumentos del lenguaje C++

Son el medio a partir del cual podemos expandir el mbito de variables locales
de funciones, hacia otras funciones y adems quienes nos permiten establecer
comunicaciones entre funciones. Si nos vemos ante la necesidad de visualizar o
modificar el valor de una variable local en otra funcin que llamaremos, debemos
invocar a dicha funcin haciendo referencia de su nombre, seguido de los
parmetros o nombres de variables para las cuales, en teora ampliaramos su
mbito.
Void funcin_llamada (int x){ // funcin que recibe un argumento
:
}
Void una funcin (void) {
Int a, b; // variables de mbito local
:
:
funcion_llamada(a); // llamada de la funcin con un parmetro
:
}
La expresin funcion_llamada(a); se denomina llamado a la funcin
funcion_llamada con un parmetro a de tipo entero. Y la expresin void
funcion_llamada (int x) se denomina cabecera de la funcin funcion_llamada con
un argumento, en este caso x, tambin de tipo entero.
Desde luego que, sobre la base de la comunicacin entre funciones y la teora
del paradigma procedimental donde aplicamos la disgregacin de procesos, nos
podemos encontrar con las siguientes variantes:
1. Llamado de funciones sin pasar parmetros.
2. Llamado de funciones pasando parmetros.
Est claro que dichas funciones pueden o no devolvernos valores hacia el origen
de su llamado.
Entonces, pasamos como parmetros nombres de variables al llamar una
funcin, que deben corresponderse en su tipo al ser recibidos sobre los
argumentos de dicha funcin. Esto bsicamente es correcto, pero debemos
completar la idea describiendo con claridad los tipos de parmetros que nos
permite manejar el lenguaje C++.
Tipos de parmetros:
Los tipos de parmetros a utilizar van a depender siempre de la necesidad que
se le presente al programador. De todos modos hay dos necesidades bsicas
que generalmente estn vigentes:
1. Poder obtener el contenido de una variable.
2. Poder modificar el contenido de una variable.
Parmetros por valor:
Cuando surge la necesidad de obtener el valor o contenido de una variable
original o local a una funcin, en otra funcin, se utiliza parmetros por valor. En
este caso se produce una copia de la variable original hacia el argumento formal
de la funcin receptora. Dicha variable tendr como mbito la funcin receptora
y al culminar esta liberar el espacio de memoria que ocupa.
Void imprime_cantidad (int can) {
Printf (%d\n, can);
}
Void alguna_funcion (void) {
Int cantidad;
:
imprime_cantidad (cantidad);
:
}
El valor de una variable original puede pasar de una funcin a otra y a su vez a
otras funciones, sin inconvenientes. De pronto en nuestro desarrollo, nos
podemos encontrar con una hoja de ruta de valores de variables que pasan por
funciones.
Si usamos parmetros por valor, nunca podremos modificar los valores de las
variables originales ya que se producen copias de las mismas hacia las variables
de la funcin llamada y su mbito es local.
Al utilizar parmetros por valor, stos pueden ser constantes como por ejemplo:
#include <Studio.h>
Void imprime_datos (char nombre [], int edad) {
Printf ("Nombre: %s, edad: %d\n", nombre, edad);
}
Void main (void) {char alias [35] = {"Pepe"};
imprime_datos (alias, 23);
}
Parmetros por referencia:
La referencia indica trabajar sobre la direccin de memoria que ocupa el
parmetro o variable original.
Void ingresar_cantidad (int &can) {
Cin>>can;
}
Void alguna_funcin (void) {
Int cantidad;
:
ingresar_cantidad (cantidad);
:
}
Como se observa en este ejemplo, el argumento de la funcin receptora,
presenta el operador unario & precediendo al nombre de la variable. Esto indica
que se tome la direccin del parmetro hacia el argumento, produciendo un
espejo o alias de la variable original cantidad. Lo cual significar, que toda
alteracin producida sobre el argumento can, afectar a la variable original o
parmetro cantidad.
Siempre que surja la necesidad de afectar a las variables originales debemos
usar parmetros por referencia. Algunos casos seran: cargar un dato o
recalcular un dato.
Ya que las funciones devuelven solo un valor, es habitual usar varios parmetros
por referencia cuando necesitamos que una funcin provoque varios resultados
y no solo uno.
Si al argumento por referencia lo precedemos de la palabra const, dicha variable
no podr ser alterada en el mbito de la funcin receptora, por lo tanto nunca
afectar a la variable original.
#include <iostream>
Void icrementa_sin_exito (int b)
{b++;} // No afecta a la variable original a void incrementa_con_exito
(Const int &b) {b++;} // Error de compilacin
Void main (void) {
Int a = 4;
Cout<<a<<"\n";
incrementa_sin_exito (a);
Cout<<a<<"\n";
incrementa_con_exito(a);
Cout<<a<<"\n";
}
Si extraemos la palabra reservada const del argumento b en la funcin
incrementa_con_exito (), no habra error de compilacin y la variable original a
se vera afectada al incrementarse en uno por el b++.

Operadores
Los operadores son smbolos que indican cmo son manipulados los datos. Se
pueden clasificar en los siguientes grupos: aritmticos, relacionales, lgicos,
unitarios, a nivel de bits, de asignacin, operador condicional y otros.
Operadores de asignacin:
Tal y como su nombre lo indica, este tipo de operadores permiten la asignacin
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 asignacin
simple, los dems son operadores de asignacin compuestos, puesto que estn
conformados por ms de un smbolo, 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 seccin de operadores de bits
Operadores aritmticos
Los operadores aritmticos se usan para realizar clculos y operaciones con
nmeros reales y punteros. Bsicamente permiten hacer cualquier operacin
aritmtica que se necesite. Los operadores ms comunes son:

La operacin modulo corresponde a obtener el residuo de la divisin, 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 divisin exacta.
Es necesario hacer una observacin acerca de los operadores de incremento y
decremento, ya que dependiendo de su ubicacin 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 es posterior a la variable se encuentra en
la forma posfija y se le llama pos-incremento o pos-decremento segn el caso.
Tambin existen operadores para los punteros, sin embargo estos solo aplican
para aquellos apuntadores a matrices, arreglos o listas de elementos, y aunque
se muestran a continuacin, se explicaran de una mejor forma en el material de
apuntadores o punteros en C++.

Operadores relacionales:
Los operadores relacionales, tambin denominados operadores binarios lgicos
y de comparacin, se utilizan para comprobar la veracidad o falsedad de
determinadas propuestas de relacin (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 aritmticos 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 definicin, un operador
relacional, produce un bool (true o false) como resultado, aunque en
determinadas circunstancias puede producirse una conversin automtica de
tipo a valores int (1 si la expresin es cierta y 0 si es falsa).
Operadores lgicos:
Los operadores lgicos producen un resultado booleano, y sus operandos son
tambin valores lgicos o asimilables a ellos (los valores numricos son
asimilados a cierto o falso segn su valor sea cero o distinto de cero). Por el
contrario, las operaciones entre bits producen valores arbitrarios.
Los operadores lgicos son tres, dos de ellos son binarios y el ltimo (negacin)
es unario:
AND lgico:
Devuelve un valor lgico 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 expresin, se evala para
obtener el resultado (esta computacin puede tener ciertos efectos laterales). A
continuacin, el valor obtenido es convertido a bool cierto/falso siguiendo las
reglas de conversin estndar. Si el resultado es false, el proceso se detiene y
este es el resultado, sin que en este caso sea necesario evaluar la expresin de
la derecha (recurdese que en el diseo de C++ prima la velocidad).
Si el resultado del operando izquierdo es cierto, se contina con la evaluacin de
la expresin de la derecha, que tambin es convertida a bool. Si el nuevo
resultado es true, entonces el resultado del operador es true. En caso contrario
el resultado es false.
OR lgico:
Este operador binario devuelve true si alguno de los operandos es cierto. En
caso contrario devuelve false. Este operador sigue un funcionamiento anlogo al
anterior. El primer operando (izquierdo) es convertido a bool. Para ello, si es una
expresin, se evala para obtener el resultado (esta computacin puede tener
ciertos efectos laterales). A continuacin el valor obtenido es convertido a bool
cierto/falso siguiendo las reglas de conversin estndar. Si el resultado es true,
el proceso se detiene y este es el resultado, sin que en este caso sea necesario
evaluar la expresin de la derecha (recurdese que en el diseo de C++ prima
la velocidad).
Si el resultado del operando izquierdo es false, se contina con la evaluacin de
la expresin de la derecha, que tambin es convertida a bool. Si el nuevo
resultado es true, entonces el resultado del operador es true. En caso contrario
el resultado es false.
Negacin lgica:
Este operador es denominado tambin No lgico y se representa en el texto
escrito por la palabra inglesa NOT (otros lenguajes utilizan directamente esta
palabra para representar el operador en el cdigo). El operando (que puede ser
una expresin que se evala a un resultado) es convertido a tipo bool, con lo que
solo puede ser uno de los valores cierto/falso. A continuacin el operador cambia
su valor; Si es cierto es convertido a falso y viceversa.
Operadores de bits:
Los operadores de movimiento son operadores a nivel de bits, y lo que hacen es
convertir una determinada cantidad a su equivalente en bits para posteriormente
realizar un desplazamiento de dicho valor. Estos operadores son:
El resultado de los operadores AND, XOR y OR es independiente del orden de
colocacin de sus operandos. Los operadores que gozan de esta propiedad se
denominan asociativos. Viene a ser equivalente a la propiedad conmutativa de
ciertos operadores aritmticos.
Operadores de direccin:
Adems de los operadores aritmticos, de los que existen versiones para los
tipos numricos y para los punteros, C++ dispone de dos operadores especficos
para estos ltimos (punteros de cualquier tipo): la indireccin * y la referencia
& . Adems existen dos operadores especficos para punteros-a-clases.

Entrada y salida C++

Definicin: un stream en C++ es un objeto mediante el cual un programa puede
insertar o extraer datos utilizando los operadores de insercin << y de extraccin
>> o funciones.
Los datos pueden ser tipos fundamentales (int, char, double, etc.), o cadenas de
caracteres.
Ejemplo:
Cout << Hola!; // muestra una cadena de texto en la pantalla
Cout << 120; // muestra un nmero en pantalla
Cout << x; // muestra el valor de la variable x en pantalla
El operador de insercin << puede concatenarse:
Cout << Nombre: << nom << Edad: << ed;
Suponiendo que la variable nom contenga la cadena Carla y la variable ed
contenga el entero 23, la salida en pantalla ser:
Nombre: Carla Edad: 23
Para separar las lneas en pantalla pueden usarse dos mtodos: agregar \n o
usar el manipulador endl:
Cout << Nombre: << nom << \n << Edad: << ed;
O
Cout << Nombre: << nom << endl << Edad: << ed;
En ambos casos la salida ser:
Nombre: Carla
Edad: 23
La entrada estndar de un programa C++ es el teclado, y est representado
por el stream cin. El operador de extraccin >> permite obtener caracteres o
nmeros desde el teclado:
Int temperatura;
Cin >> temperatura;
Es importante recordar que cin slo procesa la entrada desde el teclado una vez
que el usuario puls la tecla Enter. El tipo de la variable que recibe datos
determina cmo se interpretan los datos ingresados por teclado. El operador de
insercin puede concatenarse, por ejemplo:
Cin >> a;
Cin >> b;
Es equivalente a:
Cin >> a >> b;
La librera iostream provee dos streams predefinidas ms: cerr, que es la salida
estndar de errores y clog, la salida estndar de registro o logging.
Streams especiales: archivos C++ provee tres streams especficas para leer y
escribir caracteres desde y hacia un archivo en disco:
1. ifstream para leer caracteres desde un archivo
2. ofstream para escribir caracteres en un archivo
3. fstream para leer y escribir caracteres en un archivo Estas clases derivan
de istream y ostream, las clases bsicas de entrada/salida definidas en
iostream, y estn especialmente diseadas para interactuar con archivos
en almacenamiento no voltil (disco, pen drive, etc.).
Utilizacin Un ejemplo sencillo de uso de ofstream:
Un ejemplo sencillo de uso de ofstream:
#include <iostream>
#include <Ofstream>
 Using namespace std;
Int main () {
Ofstream myfile;
Myfile. Open ("salida.txt");
Myfile << "Escribiendo en archivos.\n";
Myfile. Close (); return 0 ;}
Este programa crea (o abre, si existe) un archivo llamado salida.txt y escribe
una cadena de texto en su interior.
Apertura de un archivo Para utilizar un objeto ifstream, ofstream o fstream
debe llevarse a cabo la vinculacin del stream al archivo fsico mediante una
operacin de apertura mediante la funcin open (), que toma dos argumentos:
nombre del archivo y modo de apertura. El primer parmetro es una cadena
de caracteres (const char *) terminada en '\0' y opcionalmente el segundo,
que una constante que determinar el uso que pretendemos hacer del archivo
segn la siguiente tabla:

Los modos pueden combinarse utilizando el operador OR '|':

Ofstream arch;
arch.open (datos.txt, ios::out | ios::app | ios::binary);
En este caso, datos.txt se abre para escribir datos binarios, preservando su
contenido actual. En todos los casos, la funcin is_open() permite verificar si un
archivo est disponible para operar sobre el:
If (arch.is_open () {// se puede operar}
Else cout << Archivo cerrado;
Cierre de un archivo Para garantizar que las operaciones realizadas
efectivamente se reflejen en el archivo en disco, cuando se termina de trabajar
sobre l debe ejecutar una operacin de cierre mediante la funcin close ():
arch.close ();
Manipuladores La librera estndar iostream provee un conjunto de funciones
llamadas manipuladores que, utilizados en conjunto con los operadores << y >>
permiten modificar el comportamiento de los streams. La tabla siguiente muestra
algunas frecuentemente utilizadas:
 CONCLUSIN
A lo largo del desarrollo de esta respectiva investigacin fueron implementados
diversos temas propuestos a los elementos del lenguaje C++ tales como los tipos
de datos, los operadores, las entradas y salidas, el encabezado, etc. Todos con
su aplicable ejemplo de un programa completo.
Resumiendo todo el contenido de la correspondiente investigacin puedo
empezar explicando que C++ es un lenguaje orientado a objetos de manera
hbrida, es decir que puede ser implementado con este paradigma o no, a
diferencia de otros que trabajan totalmente en la programacin orientada a
objetos. Por eso considero que este lenguaje es muy apreciable para aprender
y aplicar en diversos proyectos.
Con esto puedo proceder a explicar la estructura base de un programa,
partiendo todos los elementos que este integre al momento de compilar.
Primeramente puedo presentar el encabezado con los preprocesadores, el cual
con esto a travs de #include es posible la integracin de ficheros externos o
bibliotecas que no contemos como tal en el lenguaje pero que sin embargo
podemos habilitarla con el respectivo fichero.
En este caso se usa #include <iostream> indicando con esto que usaremos
elementos de entrada y salida debido a que como tal no lo integra el lenguaje
C++.
Seguidamente tenemos el using namespace std; Donde es posible el
entendimiento de esta sabiendo que nos permite usar espacios de nombres.
Por consiguiente, tenemos la funcin int man (),en este integraremos todos los
comandos que queremos que se ejecuten de manera principal, y debido a que
es colocado el int, estamos indicando que es una funcin que devuelve un valor
entero, pero como es la funcin principal no queremos que devuelva nada, por
lo tanto se indica que es return 0;.
Con esto concluyo adecuadamente con esta respectiva investigacin, resaltando
que pude entender los temas con la ayuda de fuentes oficiales como las
bibliogrficas, es decir, a travs de libros que se especializan en este tema de
programacin y especficamente al lenguaje C++.
 BIBLIOGRAFA
Sierra, F. J. (2009). Enciclopedia del lenguaje C++. Madrid: Alfaomega.

REFERENCIA ELECTRNICA
https://www.programarya.com/Cursos/C++/Estructura
http://www.dsi.fceia.unr.edu.ar/downloads/informatica/info_II/El_Lenguaje_C.pd
f
https://www.nebrija.es/~abustind/Informatica/MetodologiaI/Elementos_basicos_
C.pdf
http://www.dsi.fceia.unr.edu.ar/downloads/Entrada-SalidaCplusplus.pdf
https://www.programarya.com/Cursos/C++/Sistema-De-Tipos/Variables-Y-
Constantes