Está en la página 1de 50

REPÚBLICA BOLIVARIANA DE VENEZUELA.

INSTITUTO UNIVERSITARIO POLITECNICO “SANTIAGO MARIÑO.”

EXTENSION-BARINAS.

Profesor: Alumno:

Ing. Pedro Pérez Cesar Mena 30006277

Ing. de Sistemas

Materia:

Programación I
Índice:

Pág:
1.-Introduccion………………………………………………………………..3

2.- Entorno de Trabajo………………………………………………………4

3.- Descripción de las opciones del Menú………………………………5

4.- Datos……………………………………………………………………….9

5.- Instrucciones……………………………………………………………..13

6.- Funciones en Dev C++………………………………………………….20

7.-Ventajas que presenta…………………………………………………..34

8.-Desventajas………………………………………………………….……34

9.-Consejo para el trabajo con el software………………………..……35

10.-Características………………………………………………..…………35

11.-Operadores aritméticos………………………………………………..36

12.-Operadores de asignación…………………………………………....37

13.-Operadores lógicos……………………………………………………40

14.-Librerias…………………………………………………………………..43

15.-Conclusión………………………………………………………………48

16.-Bibliografia…………………………………………………………….....49

17.-Anexos……………………………………………………………………50
1.-Introducción:

Dev-C++ es un Entorno Integrado de Desarrollo para el lenguaje de


programación C/C++ que usa Mingw (Minimalist GNU for Windows,
www.mingw.org ) de GCC (GNU Compiler Collection
www.gnu.org/home.es.html ). Es un software de libre distribución
(www.bloodshed.net) sujeto a los términos de la Licencia Pública General
(GPL) de GNU. Algunas de las características de Dev-C++ son: - Soporta
compiladores basados en GCC, por ejemplo Mingw. - Tiene integrado un
depurador basado en GDB (Gnu DeBugger). - Mantiene una lista con las
clases utilizadas durante la edición de un programa. - Mantiene una lista de
las funciones definidas en la implementación del programa. - Tiene un
manejador de proyectos. - Soporta la actualización del software y bibliotecas
a través de Internet.
2.- Entorno de Trabajo:

Se pueden identificar 4 áreas principales:


1. Menú y barras de herramientas
2. Explorador de proyectos
3. Área de trabajo y edición.
4. Resultado de la compilación.

1. Menú y barras de herramientas:

Aquí tenemos los menús con los típicos comandos de Windows (abrir,
guardar, copiar y pegar…)También tenemos una serie de iconos en las
barras de herramientas que no son más que una parte de las opciones que
tenemos en los menús, se puede dejar el ratón encima de un icono durante
unos segundos y aparecerá una ayuda emergente. Explicativa de lo que se
ejecuta cuando se hace clic sobre la figura. En el numeral 4 se hará una
pequeña descripción de cada una de las
opciones del menú.

2. Explorador de proyectos y clases e información de depuración:

Dependiendo de la pestaña que seleccione en esta área tendrá acceso a:

a) Explorador de proyectos, que muestra los archivos por los que está
formado el proyecto -y por
tanto su aplicación- bien sean de código, de encabezados, o de recursos.

b) Explorador de clases, una de las funciones más útiles, más adelante se


detallará cada una de
las estructuras/clases definidas en los archivos del proyecto, así como los
métodos y datos que
forman parte de la estructura/clase, incluyendo sus argumentos y su tipo.
También se verá una lista
de las funciones globales que tenemos en el proyecto, también con sus
argumentos. Pulsando
doble clic en un método, función o clase, se irá directamente al archivo y
línea donde se ha definido.
c) Información de depuración, aquí podremos definir las variables que
queramos cuando estemos
depurando un programa.

2. Área de Trabajo y edición:

Aquí aparecerán los Archivo de código que se abran. Se Pueden tener


abierto más de un Archivo a la vez, y seleccionarlo por medio del menú
Windows.

3. Resultados de la compilación y controles de depuración:

En ésta serie de pestañas se encuentra información acerca del proceso de


compilación. Cuando se selecciona una pestaña se expandirá para
mostrarnos los resultados. En la pestaña ―compiler‖ (compilador) se ven los
errores y advertencias que ha generado la compilación de nuestro código (si
los hubiera), pulsando doble clic en uno de ellos se remite directamente a la
línea que provocó dicho error o advertencia. También se generan avisos.
También existen otras pestañas, con propósitos más específicos, ―linker‖,
informa acerca de la correcta referencia de las librerías con el código que
hemos creado. ―resource‖, indica posibles advertencias acerca de otros
recursos invocados en las líneas de código de nuestro
programa,y―CompileLog‖, informa acerca de diferentes mensajes que
produzca la herramienta de compilación.

3.-Descripción de las opciones del Menú:

a) Menú File:

Permite realizar operaciones con ficheros y salir del programa:

 Nuevo proyecto
 Nueva plantilla
 Abrir proyecto existente o Archivo
 Abrir archivos recientes
 Fichero nuevo
 Nuevo recurso
 Guardar
 Guardar con otro nombre
 Guardar todos los Archivos abiertos
 Cerrar proyecto
 Cerrar ventana actual
 Exportar a HTML o RTF (Word)
 Imprimir
 Setup impresora
 Salir del Programa

b) Menú Edit:

Acciones que se pueden realizar para las tareas de edición de texto:

 Deshacer
 Rehacer
 Cortar
 Copiar
 Pegar
 Insertar
 Insertar una marca
 Ir a una marca
 Seleccionar todo el contenido de la ventana

c) Menú Search:

Para hacer búsquedas en el texto:


 Buscar
 Buscar la siguiente aparición
 Buscar y reemplazar
 Ir a la línea número. . .

d) Menú Project:

En este menú se pueden gestionar los elementos que pertenecen a un


proyecto:

 Nuevo proyecto
 Nuevo elemento al proyecto (adicionar archivo)
 Eliminar archivo del proyecto
 Abrir un archivo para editar
 Generar un archivo ―make‖
 Opciones del proyecto.

e) Menú Execute:

En este menú encuentra las herramientas necesarias para generar los


archivos ejecutables de un
Proyecto:

 Compilar (generar un programa)


 Correr el programa
 Compilar y correr
 Reconstruir todo
 Depurar
f) Menú Options:

 Opciones del compilador


 Opciones de ambiente
 Estilo visual de iconos.

g) Menú Tools:

 Muestra la ventana de resultado de compilación


 Herramientas para configurar Dev C++
 Muestra la línea de comandos del DOS
 Activa el Explorador de Windows
 Control de grupos de archivos
 Creador de archivos de instalación.

h) Menú Windows:

Ordena las ventanas por mosaico:

 Ordena las ventanas en cascada


 --
 Cerrar todas las ventanas
 Minimizar todas las ventanas
 Modo pantalla completa
 Siguiente ventana
 Ventana anterior
 Muestra las ventanas activas

5.-Datos:

Hay dos clases de tipos de datos: tipos fundamentales y tipos derivados.

Únicamente vamos a ver los tipos de datos fundamentales.

Tipo entero:representa números enteros con o sin signo, que estarán


compuestos por los dígitos del 0 al 9, pudiendo ser precedidos por los signos
+ o -.
Algunos ejemplo de datos enteros son: 0, 23, -176, -1, etc.

Para definir variables en Dev-C++ se antepone la palabra reservada del tipo


al identificador de la variable. El tipo de datos entero se define en el lenguaje
de programación C por la palabra reservada int.
Para definir un tipo de dato en Dev-C++ se escribe lo siguiente:

int nombre_variable = valor;


No es necesario que la variable tenga un valor predeterminado. Se puede
definir sin asignarle ningún valor.

Si tenemos varios datos que son del mismo tipo, se pueden definir todas en
la misma línea de código escribiendo un único int, separando el nombre de
las variables por ―,‖. Una vez que se haya acabado de definir variables, se
cierra la línea de código con ―;‖,
Por ejemplo: int edad = 24;
int edad;
int edad, num, contador;

Tipo real: Se emplean para representar números reales (con decimales).


Para definir datos reales se antepone la palabra reservada float al
identificador de la variable.
float identificador = valor;
Por ejemplo: float numero1, numero2;
float numero3 = 123.43;
float numero3;

Tipo carácter: Este tipo de datos se emplea para representar un carácter


perteneciente a un determinado código utilizado por el ordenador
(normalmente el código ASCII).
Para representar este tipo de dato se antepone la palabra reservada char al
identificador de la variable.
Char identificador = ‗valor‘;
Una constante tipo char se representa como un solo carácter encerrado entre
comillas simples.

Por ejemplo: char letra, letra2;

char letra=‘a‘;

Tipo cadena de caracteres: una cadena de caracteres es un número de


caracteres consecutivos (incluso ninguno) encerrado entre unos
delimitadores determinados, que en el lenguaje Dev-C++ son las comillas
dobles. Para definir variables de tipo cadena, estas se definen como vectores
de caracteres, esto es, anteponiendo la palabra reservada char al
identificador de la variable, y después entre corchetes la longitud máxima de
cadena.
Char identificador[cantidad] = ― mensaje ‖;
Por ejemplo: char cadena[20];
char cadena[20] = ―Hola mundo‖;
char cadena[] = ―HOLA‖;
En la siguiente tabla se hace un resumen de los distintos tipos de datos:

Tipo de dato Palabra reservada Ejemplo


Entero Int Int numero=0;

Real Float Float numero=12.2;

Carácter Char Char letra = ‗a‘;

Cadena de carácter Char Char palabra[10] = ―HOLA‖;

Para poder leer y escribir datos en el lenguaje de programación C existen


una serie de funciones agrupadas en un conjunto de librerías de código
objeto, que constituyen la llamada biblioteca estándar del lenguaje. En el
caso concreto de las funciones de entrada y salida (lectura y escritura), su
archivo de cabecera es stdio.h.
Existen varias funciones que realizan la entrada y salida de datos en el
lenguaje de programación C, pero nos vamos a centrar solamente en dos de
ellas: printf() y scanf().

Funcion printf()
La función printf() sirve para escribir datos en la pantalla con un formato
determinado.
El prototipo de esta función es la siguiente:

int printf(const char *formato, arg1, arg2, …, argn)


donde:

formato: hace referencia a una cadena de caracteres que contiene


información sobre el formato de salida.

Arg1, arg2, …, argn: argumentos que representan los datos de salida

La cadena de control puede constar de hasta tres tipos de información:

- texto: que será mostrado por pantalla tal cual este escrito
- Secuencias de escape: secuencias reservadas propias del lenguaje.
Van precedidas por '\' y las más importantes son '\n' que introduce un salto
de línea, y '\t' que introduce un tabulador.
- Especificadores de formato: son ciertos caracteres precedidos del
carácter tanto por ciento '%'.
A continuación se muestra una tabla con estos especificadores de formato
dependiendo del tipo de dato a los que representan:
Tipo de dato Especificadores deComentario
formato
Int %d Entero con signo

Float %f Real con signo

Char %c carácter

Char [n] %s Cadena de caracteres

Ejemplos:

printf(―\n Valores: %d, %f‖, entero, real);


Salida por pantalla:

(Retorno de carro)Valores: 2, 2.3

printf(―%s\t%d\n%f‖, concepto, num, coste);


Salida por pantalla:

Cremallera 1234

12.345

Función scanf()
La función scanf() se pude considerar de alguna manera como la inversa de
la función printf(), pues sirve para introducir datos desde el teclado con un
formato determinado.
El prototipo de esta función es el siguiente:

int scanf(const char *formato, arg1, arg2, …, argn);


donde:

 formato: hace referencia a una cadena de caracteres (cadena de


control) que contiene información sobre el formato de los datos que se
van a introducir mediante el teclado.
 arg1, arg2, …, argn: son los argumentos que representan los datos de
entrada.
La cadena de control puede constar de:

 Especificadores de formato, que son ciertos caracteres precedido


por el carácter tanto por ciento '%'.
 Caracteres de espacio
 Otros caracteres no espacios, para entradas con formato
A continuación se muestra una tabla con estos especificadores de formato
dependiendo del tipo de dato a los que representan:

Tipo de dato Especificadores deComentario


formato
Int %d Entero con signo

Float %f Real con signo

Char %c carácter

Char [n] %s Cadena de caracteres

Ejemplos:

scanf(―%d‖, numero);
scanf(―%d %s %f‖, numero, &cadena, &real);

5.-Instrucciones:

Estos son los tipos de instrucciones:


 instrucciones declarativas
 instrucciones de asignación
 instrucciones selectivas
 instrucciones repetitivas
 instrucciones de entrada y salida de datos
 instrucciones de bifurcación

Instrucciones declarativas :
Sirven para declarar librerias, variables, constantes, arreglos , punteros,
estructuras…
Por ejemplo:

1.) Para librerias:


las librerias las declaramos porque vamos a usar recursos que contienen
ellas.[ más detalles ]
#include <iostream.h> ——> cin , cout..
#include <conio.h> ——> funcion getch()..
#include <string.h> ——> para manipular cadenas
#include <math.h> ——> para operaciones numericas
#include <time.h> ——> para usar la hora
#include <stdio.h> ——> para usar alternativas de entrada – salida como
printf , scanf

2.) Para variables:

las variables las declaramos con el fin de tener un espacio para almacenar
algun dato que va a cambiar con el tiempo. [ más detalles ]
char nombre; ——> Declarando variable tipo caracter
int a,b,c; ——> Declarando variable tipo entero
double sueldo ——> Declarando variable tipo decimal
short contador ——> Declarando variable tipo entero-corto
Sugerencia: leer cuanto espacio ocupa usar cada tipo de variable [ Aqui ]
Consejo: A las unicas variables que se deben dar valores iniciales son a:
– los contadores
– los acumuladores
Pero, ¿ Cuál es la diferencia entre ambos ?
Acumuladores: se incrementa o decrementa en un valor variable.
Ejemplo: sacar el promedio de un alumno, se suman las notas ( que varían )
y se divide para el numero de notas.
Contadores: se incrementa o decrementa en una forma constante.
Ejemplo: va contando de “1 en 1” ó de “-3 en -3” , etc…
3.) Para constantes:
las constantes las declaramos con el fin de tener un espacio para
almacenar algún dato que no va a cambiar. [ más detalles ]
Se las puede declarar de dos formas:
Tomemos como ejemplo la formula para hallar el área de un triangulo:

¿ qué es lo que nunca cambia ?


La base puede variar, la altura puede variar. Pero como vemos el ―2‖ es
constante, sea cual sea la base o la altura el 2 se queda ahi. Entonces si
queremos
declarar al ―2‖ como una constante, podemos hacerlo de dos maneras:
1) anteponiéndole ‖ #define ‖ al nombre de la constante y luego el valor que
le corresponde, así:
#define nomb 2
( lo puse de color para que se entienda mejor )
Nota: al usar éste método no se le pone el delimitador ‖ ; ‖ al final de la línea.
A continuación coloco un ejemplo en código, para que tengan una idea de
como seria:
#include <iostream.h>
main()
{
#define nomb 2 ——> Declarada la constante de la forma 1.
int base,altura,area;
cout<<“Ingrese base: \n”;
cin >>base;
cout<<“Ingrese altura: \n”;
cin >>altura;
area = ( base * altura )/nomb;
cout<<“El area del triangulo es: “<< area <<endl;
system(“pause”);
}
2) anteponiéndole ‖ const ‖ seguido del tipo de variable que és, después el
nombre de la constante y luego el valor que va a contener, asi:
const int nomb = 2;
( lo puse de color para que se entienda mejor )
Nota: a diferencia del método anterior, éste si lleva el delimitador ‖ ; ‖ al final
de la línea.
A continuación coloco un ejemplo en código, para que tengan una idea de
como seria:
#include <iostream.h>
main()
{
const int nomb = 2; ——> Declarada la constante de la forma 2.
int base,altura,area;
cout<<“Ingrese base: \n”;
cin >>base;
cout<<“Ingrese altura: \n”;
cin >>altura;
area = ( base * altura )/nomb;
cout<<“El area del triangulo es: “<< area <<endl;
system(“pause”);
}
4.) Para arreglos:

los arreglos son un conjunto de variables del mismo tipo y nombre, pero
indexadas por una posición diferente.
float vector [12]; ——> Declarando un arreglo tipo flotante ( decimal )
ése ―vector‖ que se ha declarado arriba, al ser un arreglo quiere decir que
hay 12 variables con el mismo nombre
y son del mismo tipo, pero diferenciadas únicamente en su posición, así:
vector[0],vector[1],vector[2],vector[3],vector[4],vector[5],vector[6], …………..
,vector[10],vector[11].
Nota: los arreglos siempre comienzan en la posición cero ( 0 ) por eso llegan
hasta una unidad menos, en éste caso como declaramos
un arreglo de 12 , su tope será de 11; puesto a que desde cero ( 0 ) hasta
once ( 11 ) hay doce ( 12 ) variables

5.) Para punteros:

los punteros son variables que almacenan direcciones de memoria y se los


reconoce por llevar un ―asterisco‖ ( * ) delante del nombre de la variable, así:
float * ventas ;
6.) Para estructuras:
las estructuras son una agrupación de variables que forman un registro, se
las denota de ésta manera:
struct alumno
{
int cedula;
char nombre;
short edad;
}
Instrucciones de asignación:
Sirven para dar valores a las variables, y llevan éste formato:
nombre_variable = expresión ;
Por ejemplo:
a = 15 ;
x=a+5;
z=x/2;
Instrucciones selectivas :
Son mediante las cuales podemos ejecutar diferentes acciones, como
resultado de una expresión que estemos evaluando en ese momento y
pueden ser:
– Las selectivas simples
– Las selectivas dobles
– Las selectivas multiples
1.) Simples:
Las que como resultado de una expresión que se esté evaluando, solo
podemos ejecutar una opción por verdadero; ejemplo:
if ( expresión a evaluar ) ——> Si ésa expresión es verdadera y solo es
verdadera, se ejecutarán las acciones.
{
acción_1;
acción_2;
}
2.) Dobles:
Nos permite seleccionar entre dos diferentes acciones:
– Una por verdadero
– Otra por falso
De ésta manera:
if ( expresión a evaluar ) ——> Si ésa expresión es verdadera, se
ejecutarán las acciones 1 y 2.
{
accion_1;
accion_2;
}
else ——> Pero si ésa expresión era falsa, se ejecutarán las acciones 3 y 4.
{
accion_3;
accion_4;
}
A profundidad: para ver más sobre el manejo de la condición if , puede
acceder [ Aqui ]
3.) Multiples:
Podemos ejecutar diferentes acciones como resultado de una expresión que
estemos evaluando; ejemplo:
switch ( expresion a evaluar ) ——> Esta es la expresión que vamos a
evaluar.
{
case 1 : accion 1 ;
case 2 : accion 2 ;
case 3 : accion 3 ;
}
Instrucciones repetitivas :

Sirven para repetir una condición N veces, siempre y cuando la condición


sea verdadera.
a) Cuando no sabemos cuántas veces tendrá que ejecutarse una acción para
que sea verdadera, se usa el While y el Do – While. Estas dos instrucciones
repetitivas son muy parecidas en su función, y llegan al mismo resultado.
Solo cambia la sintaxis:
– Para while:
While ( expresión ) ——> Mientras esa expresión sea verdadera
hará las acciones 1 y 2.
{
acción 1;
acción 2;
}
– Para Do – While:
Do
{
acción 1;
acción 2;
} While ( expresión ) ——> Mientras esa expresión sea verdadera
hará las acciones 1 y 2.
b) Cuando sabemos cuántas veces queremos que se realice una acción,
pues usamos la instrucción repetitiva ‖ for ―, su sintaxis es la siguiente:
for ( expresión inicial ; expresión final ; incremento / decremento )
{
acciónes; ——> Hasta que no llegue a la “expresión final“, se ejecurá la
acción una y otra vez.
}
Nota: Sobre los operadores de incremento y decremento, puedes ver más
información [ Aquí ]

Instrucciones de entrada y salida de datos:


El lenguaje C++ no tiene palabras reservadas para ingresar o mostrar datos,
para ello usan recursos que se encuentran en las librerias.
Por ejemplo:
En la libreria <iostream.h> tenemos para la entrada y salida de datos
a cin y coutrespectivamente.
Uso:
– Para la entrada de datos ( pedir )
cin >> nombre_del_usuario ;
– Para la salida de datos ( mostrar )
cout << nombre_del_usuario
En la libreria <stdio.h> tenemos para la entrada y salida de datos
a scanf y printfrespectivamente.
Uso:
– Para la entrada de datos ( pedir )
scanf ( ‖ %i %s %f ‖ , &edad apellido &sueldo ) ;
Nota: Los amperson ( & ) van en todo tipo de variable menos en las cadenas
de caracteres cuando usamos el scanf.
– Para la salida de datos ( mostrar )
printf ( ‖ su edad es: %i ‖ , edad )

Instrucciones de bifurcación:

Interrumpen el flujo normal de un programa, es decir que evitan que se


ejecute alguna instrucción del programa y salta a otra parte del programa.
Por ejemplo: el ― break ―
Switch ( expresión que estamos evaluando )
{
case 1 : cout << ‖ Hola! ― ; break ;
case 2 : cout << ‖ amig@s ― ;
}
En el ejemplo anterior tenemos, que en caso de que haya sido ―1‖ pues
mostrará ―Hola!‖ y saldrá del programa dejando a un lado lo demás.
Entonces hemos comprobado que interrumpió el flujo normal del programa.
Pero si tuvieramos algo de ésta manera:
Switch ( expresión que estamos evaluando )
{
case 1 : cout << ‖ Hola! ― ;
case 2 : cout << ‖ amig@s ‖ ;
case 3 : cout << ‖ bienvenidos a ― ;
case 4 : cout << ‖ Programando: Paso a Paso ― ; break ;
}
Entonces el flujo normal del programa avanza hasta el caso 4 dónde vemos
que está el ‖ break ‖ y él pues interrumpe el flujo normal del programa y ahí
acabaría nuestro programa, como resultado nos hubiera mostrado lo
siguiente: ‖ Hola! amig@s bienvenidos a Programando: Paso a Paso ―.
Asi mismo, hay otras que cumplen funciones parecidas como por ejemplo:
continue : éste hace que se salte la instrucción en donde está y pase a la
siguiente, por ejemplo:
for ( x=1; x<10; x++ )
{
if ( x == 5 ) continue;
cout << x << endl;
}
Como resultado muestra: 1 – 2 – 3 – 4 – 6 – 7 – 8 – 9
No muestra el número 5, porque ahi se encuentra el continue.
goto : éste nos lleva a una línea que indiquemos por medio de etiquetas. Así:
A:
………….
………….
………….
if ( x == 100 ) goto A ;
Y otros como ‖ return ‖ que devuelve un valor ( usado en funciones por lo
general ), otro es ‖ exit ‖ que obliga a salir.

6.-Funciones en Dev-C++:

Una función es un conjunto de instrucciones que se la puede llamar desde el programa


principal o desde otras funciones. Las funciones sirven para desarrollar algo en especial
cuando el programa así lo necesite. Pará usar funciones, se deben tener en cuenta dos
cosas que necesita:1.La declaración de la función: Esto sirve para que al compilar el
programa, el compilador reconozca que esa función existe; ya que si se llama desde
alguna parte del programa sin haberla declarado o habiéndola declarado, se la declaró
mal eso dará error. Pará declararla se sigue la siguiente sintaxis:
prototipo_de_funcion
nombre_de_la_funcion( parametros opcionales );¿Qué es prototipo y qué son
parámetros? -
Prototipo de la función: sirve para indicar que va a retornar la función, si va a
retornar un entero, un double, un char, o simplemente no retorna nada (void). Esto es
obligatorio.-
Parámetros: son los datos que recibe o que se le envían a la función para que con
ellos posiblemente desarrolle algo que se necesite. Esto es opcional. Entonces, una
función para ingresar podría ser así:
void
ingresar();Donde se aprecia que
no
va a retornar nada (por ello tiene void); entonces, la función hace lo que tiene que hacer y
termina, no devuelve nada. Un ejemplo de devolución seria en una suma de enteros, ya
que se le podría enviar comodato los dos números y la función haría internamente la
suma devolviendo la suma de dichos números (si son todos enteros, devolvería un int. Si
son enteros y flotantes devolvería unfloat ), así:
int
suma_enteros (
int
,
int
); // suma únicamente enteros, devuelve un entero
float
suma_ números (
float
,
float
); // suma enteros o flotantes, devuelve un flotante 2.La definición de la función:
Sirve ya para desarrollar la función; es decir ya programar dentro de ella para que haga lo
que se necesita. Como consecuencia de que ya está creada se puede usarla, pero si no
se hubiese declarado y se desarrolla (hacemos la definición), al compilar dará error y dirá
que esa función no fue declarada, que no existe. La definición es muy similar a la
declaración, solo que esta vez lleva un ambiente (donde se va a programar,
es decir las llaves ―{ … }‖ ),
así:
void
ingresar() {
………
// Lo que deba hacer esa función}También otra diferencia es que la
declaración
lleva ―;‖ (punto y coma) al final, la
definición nolo lleva.
Ejemplo
:Hacer un programa que pida dos datos llamando a una función sin retorno y
luego confirme si se ingresaron correctamente.
Solución:
El programa debe usar una función sin retorno, es decir una void. Se deben
pedir en esa función dos valores; en este caso se van a pedir dos cosas:
nombre y número de la suerte; luego se mostrará el mensaje de que se
ingresaron correctamente dichos datos.#include <iostream.h>#include
<conio.h> // se declara la función
―ingresar‖

void
ingresar();main(){cout<<

\n Ingrese los datos: \
n‖
;ingresar();cout<<

\n Los datos se ingresaron correctamente! \
n‖
;getch();} //se define la función
―ingresar‖

void
ingresar(){
char
nombre[10];
int
numero;cout<<

\n Ingrese su nombre: \
n‖
;cin>>nombre;cout<<

\n Ingrese su numero de la suerte: \
n‖
;cin>>numero;}La declaración de una función debe estar siempre antes de la
definición, por eso es recomendable que se la coloque al inicio del programa
debajo de las librerías.Ya que se creó una función
llamada ―
ingresar

para pedir los datos por medio de ella y no pormedio del cuerpo principal
main(), se debe
llamar o invocar
para que ejecute lo que tiene programado en su interior ya que por sí sola
(sin ser llamada), el programa terminaría y ella no realizaría alguna acción.
Para llamar o invocar una función lo único que se debe hacer es escribirla tal
cual fue declarada sin alteraciones ya que las funciones sonkey sensitive, es
decir que no es lomismo :void HOLA();quevoid HoLa(); Pues aunque son la
misma palabra pero escrita diferente, para el compilador son dos funciones
diferentes.

Para llamar a la función se coloca tal como fue declarada seguida del punto y
coma (no se le pone el
prototipo
), solo el nombre y los posibles parámetros que lleve.
FUNCIONES EN DEV-C++ (PASO POR VALOR)
Las funciones no solamente son llamadas para que realicen cierta
necesidad, sino que en algunas ocasiones para que la función desarrolle
dicha necesidad
Necesita que se le envíen parámetros.
Los parámetros que se le enviarán a la función para que ella pueda cumplir
su papel correctamente, pueden ser enviados de dos maneras:
1) Pasar los parámetros por valor (paso por valor)

2) Pasar los parámetros por referencia (paso por referencia)


¿Qué es el paso por valor? Es enviarle un parámetro (variable, constante,
entre otros) a otra función que para resolver su contenido necesita
obligatoriamente recibir ese parámetro; es decir, la función depende de los
parámetros para funcionar .¿Al pasar por valor los parámetros qué se hace
en sí? Se envía
el contenido de algo
(ya sea una variable, constante) para que la función de destino la use y
pueda completar con éxito su objetivo. Pero se debe tener en cuenta que al
pasar por valor; la variable original nose altera, se envía
una ―
copia
‖ de ella a la cual si se le aplican cambios serán alterados
únicamente en ella, más no en la original.¿Cómo se declara una función que
reciba parámetros por valor?La sintaxis sería la siguiente:
prototipo_de_la_función
nombre_de_la_función (
tipo_de_dato
del parámetro1,
tipo_de_dato
del parámetro2
,…)
;

Ejemplo:
void
suma (
int
,
int
)
;
Se declara una función
―suma‖ que va a recibir dos
Parámetros que serán enteros porque el tipo de dato lo denota así. Aquellos
parámetros son por valor, lo denotamos por el hecho que únicamente va el
tipo de dato
en los paréntesis. El prototipo de la función
―suma‖ es
void
, es decir que no va a retornar valores, será un procedimiento. Si retornara
un entero sería
int
el prototipo, un número con decimales sería
float
el prototipo, entre otros.¿Cómo se define una función que recibe parámetros
por valor?La definición de la función
―suma‖:

Ejemplo:

void
suma(
int
n1,
int
n2)

{
….
}Donde n1 y n2 son variables formales.

¿Qué son variables formales? Son aquellas que se declaran en el


momento de recibir el parámetro en la función de destino, tienen el contenido
de una variable existente; pero no tiene necesariamente el mismo nombre.
Por ejemplo, en éste código:
// sueldo = 100. // comisión = 20. main() {
…………………

………….

…….

suma ( sueldo, comision);

….

……
}
void
suma (
int
n1,
int
n2) {
….
}
Se observa que en el cuerpo principal (main), se hace un llamado a una
función
―suma‖ que
recibe como parámetros dos números enteros. En éste caso será el sueldo y
la comisión de un empleado. La función
―suma‖ los recib
e y con esos valores hará un proceso interno. Pero, al momento de llamar a
la función
―suma‖
se envía:
* sueldo ( variable entera )

* comision ( variable entera )


Pero en la definición de la función
―suma‖, están dos variables en donde
llega el contenido de
sueldo y comisión; aquellas variables son,n1 y n2.Como se puede ver, no
necesariamente la función debe tener en su definición el mismo nombre de la
variable que le está pasando el dato, más bien se suele recomendar cambiar
elnombre a lasvariables formales (las que se crean / se declaran en la
definición de la funciónque recibe parámetros por valor). Lo que si interesa
es que aquellas variables cualquiera que sea su nombre (en este caso n1y
n2), reciben el contenido esperado. Es decir que:Si sueldo valía
100
como estaba previsto,n1 va a tener el valor de
100
en su contenido. Si comisión valía
20
como estaba previsto,n2 va a tener el valor de
20
en su contenido. Y si a n1 y n2 se le suman500 mas,
¿qué pasa?
Quedaría así:
n1 = 600 (es decir 100 + 500 )

n2 = 520 (es decir 20 + 500 )


Pero sueldo y comisión quedarían intactos, es decir:
sueldo = 100

comision = 20

NO
se alteran las variables originales en los pasos por valor como se había
indicado anteriormente, pero si pasan su contenido exacto a las variables
formales de la función destinada que recibe parámetros. Se crea una

copia

y esas copias pueden ser alteradas pero no se alterarán las originales.
Ejemplo
:Hacer un programa que haga las veces de calculadora entre dos números,
es decir que el usuario ingresará dos números y luego el programa por medio
de funciones recibirá los números y mostrará su resultado en: suma, resta,
multiplicación y división. Luego también mostrará cuáles fueron los números
ingresados.
Solución:
Se va a crear una función para cada caso: suma, resta, multiplicación y
división.De esta manera se entenderá mejor cómo va el paso por valor en
funciones.#include <iostream.h> #include <conio.h>
void
suma(float,float);
void
resta(float,float);
void
multiplicacion(float,float);
void
division(float,float);main(){
float
n1,n2;cout<<

\n -Operaciones aritméticas básicas- \
n‖
<<

\
n Ingrese cantidad 1:‖
;cin>>n1;cout<<

\
n Ingrese cantidad 2:‖
;cin>>n2;suma(n1,n2);resta(n1,n2);multiplicacion(n1,n2);division(n1,n2);cout<
<

\n\
n Los numeros ingresados fueron: ―
<<n1<<
‖y―
<<n2;getch();}
void
suma(float x,float y){cout<<

\
n La suma = ―
<<(x+y);}
void
resta(float x,float y){cout<<

\
n La resta = ―
<<(x-y);}
void
multiplicacion(float x,float y){cout<<

\
n La multiplicacion = ―
<<(x*y);}

void
division(float x,float y){cout<<

\
n La division = ―
<<(x/y);}Lo que se hace es llamar a cada función: suma, resta, multiplicación,
división. Como la función necesita de los números ingresados anteriormente
(n1 y n2) para calcular su respectiva suma ó resta ó multiplicación ó división,
entonces debemos enviarle como parámetros aquellos datos. Pero se debe
tener en cuenta lo siguiente:

La declaración de la función debe ser acorde a la definición de la misma


función.No deben existir contradicciones por ejemplo al declarar:
void suma();
y luego al momento de usar la función ( ó al definirla ) colocar:
int suma (x, y, z)

}
Eso conlleva a errores de compilación
, porque el lenguaje es ―key sensitive‖;
es decir, que noes lo mismo suma que: Suma ó suMA ó summa, entre
otros.También con los parámetros, pues si se declara como
void
queno recibe parámetros; NO se debe después definirla como
void
que si reciba parámetros, por más que este bien escrito el nombre y el
prototipo, no coincide a la hora de ser llamada la función por el simple hecho
deque no es lo mismo:
void
resta (); -> declaracion

void
resta ( n1,n2 ) -> definicion

}
El programa muestra los números que fueron ingresados, con el fin de
reconocer que en el paso por valor
NO
se alteran las variables originales, ya que se visualizarán n1 y n2 con los
valores originales a pesar de que hubo acciones aritméticas en su contenido
(sumas,restas,..) pero esos cambios
NO
afectaron a las variables originales sino a las formales;pues esa es una de
las características de pasar por valor los datos, se pasan copias.
Dev-C++, Funciones (paso por referencia)
Las funciones por lo general reciben parámetros, éstos hasta el momento
fueron pasados ala función mediante el "paso por valor" que consiste en
hacer una copia del argumento, paraque la función trabaje con la copia y no
con el argumento original.Esto significa que si la función modificara el valor,
el original no se alteraría ya que se estámanejando una copia.Pero surgen
dos problemas:

Se podría querer modificar el argumento original y no una copia. Con gran


cantidad de variables el paso por valor (copiando) puede resultar un gasto
excesivo de memoria. Para resolver estos problemas se cuenta con las
referencias y los punteros.Una referencia a una variable es un "alias" de la
variable. Para indicarle a C++ que estamos hablando de una referencia y no
una variable anteponemos al nombre el caracter ampersand(&).Por ejemplo
una referencia llamada ref Presupuesto apuntando a un valor double se
escribiría así:
double
&refPresupuestoSi se quiere que una función trabaje con la variable original
y no con una copia se podría indicarle a la función que reciba el parámetro
como una referencia. Ejemplo: //Paso por referencia#include <iostream>
using
std::cout;
using
std::cin;
using
std::endl;
void
elevarCuadrado (int &); //prototipo de función que recibe una referencia a un
int
int
main(){
int
x = 0; //Declaración e inicialización en 0.cout << "Ingrese x para elevarlo al
cuadrado" << endl;cin >> x;cout << "antes de elevarse es " << x
<<endl;elevarCuadrado(x); //Notar que la llamada no es diferente a un paso
por valor.cout << "x despues de elevarse es " << x << endl;//muestra el valor
modificado por la funciónreturn 0;}void elevarCuadrado (int &y) //función que
no devuelve nada (void) y recibe una referencia aun int en este caso (x){y =
y*y; //La función no devuelve ningún valor, pero modifica el argumento
original (x) //ya que estamos trabajando con una referencia.}
Ejemplo
:Hacer un programa, que reciba en una función dos valores enterospero un
dato que sea pasado por referencia y otro sea pasado por valor #include
<iostream.h>#include <conio.h> void referencia ( int&, int );int A,B;main(){
cout<<‖
\
n Ingrese un valor para A: ―;

cin>>A;cout<<

\
n Ingrese un valor para B: ―;
cin>>B;
cout<<‖
\n
————————————

―;cout<<‖
\
n valor inicial de A: ―<<A;cout<<‖
\n dirección
inicial de A: ―<<&A;cout<<‖
\
n valor inicial de B: ―<<B;cout<<‖
\n dirección
inicial de B: ―<<&B;cout<<‖
\n
————————————
\n\n\n
‖;
referencia(A,B);getch();}void referencia ( int &vieneA, int vieneB ){
cout<<‖
[ PRUEBA 1 ] \
n‖;cout<<‖
\n\
n valor de *vieneA* = ―<<vieneA<<‖
\
n‖<<‖ direccion de *vieneA* = ―<<&vieneA<<‖
\
n‖<<‖ valor de *A* = ―<<A<<‖
\
n‖<<‖ direccion de *A* = ―<<&A<<‖
\n\
n‖

<<‖
\n\
n valor de *vieneB* = ―<<vieneB<<‖
\
n‖<<‖ direccion de *vieneB* = ―<<&vieneB<<‖
\
n‖<<‖ valor de *B* = ―<<B<<‖
\
n‖<<‖ direccion de *B* = ―<<&B<<‖
\
n‖<<‖ ______________________________________
\
n‖;
getch();
cout<<‖
[ PRUEBA 2 ] \
n‖;
vieneA = 10;
cout<<‖
\n\
n valor de *vieneA* = ―<<vieneA<<‖
\
n‖<<‖ direccion de *vieneA* = ―<<&vieneA<<‖
\
n‖<<‖ valor de *A* = ―<<A<<‖
\
n‖<<‖ direccion de *A* = ―<<&A<<‖
\n\
n‖<<‖
\n\
n valor de *vieneB* = ―<<vieneB<<‖
\n
‖<<‖ direccion de *vieneB* = ―<<&vieneB<<‖
\
n‖<<‖ valor de *B* = ―<<B<<‖
\
n‖<<‖ direccion de *B* = ―<<&B<<‖
\
n‖<<‖ ______________________________________
\
n‖;
getch();
cout<<‖
[ PRUEBA 3 ] \
n‖;
vieneB = 1200;
cout<<‖
\n\n valor de *
vieneA* = ―<<vieneA<<‖
\
n‖<<‖ direccion de *vieneA* = ―<<&vieneA<<‖
\
n‖<<‖ valor de *A* = ―<<A<<‖
\
n‖<<‖ direccion de *A* = ―<<&A<<‖
\n\
n‖<<‖
\n\
n valor de *vieneB* = ―<<vieneB<<‖
\
n‖<<‖ direccion de *vieneB* = ―<<&vieneB<<‖
\
n‖<<‖ valor de *B* = ―<<B<<‖
\
n‖<<‖ direccion de *B* = ―<<&B<<‖
\
n‖<<‖ ______________________________________
\
n‖;

getch();
cout<<‖
[ PRUEBA 4 ] \
n‖;
A = 44;
cout<<‖
\n\
n valor de *vieneA* = ―<<vieneA<<‖
\
n‖<<‖ direccion de *vieneA* = ―<<&vieneA<<‖
\
n‖<<‖ valor de *A* = ―<<A<<‖
\
n‖<<‖ direccion de *A* = ―<<&A<<‖
\n\
n‖<<‖
\n\
n valor de *vieneB* = ―<<vieneB<<‖
\
n‖<<‖ direccion de *vieneB* = ―<<&vieneB<<‖
\
n‖<<‖ valor de *B* = ―<<B<<‖
\
n‖<<‖ direccion de *B* = ―<<&B<<‖
\
n‖;
getch();}

7.-Ventajas que presenta.

 Es un editor muy completo.


 Tiene multitud de utilidades en paralelo.
 Incluye bibliotecas, librerías DLL y plantillas.
 Tiene incorporado ayuda en varios idiomas.

8.-Desventajas.

1. El compilador MinGW que incluye el instalador, está OBSOLETO

MinGW es una colección de herramientas de GNU/Linux de las cuales hace


uso el programa Dev-C++, diseñadas para trabajar específicamente en
Windows. El acrónimo significa "Minimalist GNU for Windows".

El problema con Dev-C++ es que el MinGW que incluye su instalador es de


hace varios años (9 años para ser exactos) lo cual hace que los programas
elaborados con él no puedan funcionar correctamente en los sistemas más
modernos, además de que presenta muchos bugs que ya fueron arreglados
en las versiones más recientes.

2. El programa presenta varios bugs (errores) que ya no serán arreglados

Dev-C++ ya no está siendo actualizado y nadie está a cargo de él. La última


versión (4.9.9.2) tiene alrededor de 340 errores (y posiblemente más) que
han estado presentes durante años. También, debido a que el sistema de
Dev-Packs ya no está siendo actualizado, esa función se ha vuelto muy
arruinada, con muchos paquetes que están obsoletos o que ya no existen.

3. La falta de funciones que los IDE más modernos sí tienen

Las funciones de depuración de Dev-C++ también son... viejas. Un


depurador es una herramienta esencial para cualquier programador, de
cualquier nivel. He oído que el depurador de Dev-C++ es realmente confuso.
9.-Consejo para el trabajo con el software:

Después de instalado, para facilitar el trabajo, es necesario configurar


algunas opciones, para eso se debe ir al menú Herramientas/Opciones
del compilador/Configuración/Linker/Generar información de debug y se
indica la opción YES, seguidamente en el mismo menú Herramientas
vamos a Opciones del entorno/Principal: Activar Crear archivo de
respaldo, después Opciones del editor/ y se marca Activar Resaltar llaves
y paréntesis concordantes. Después en Opciones del editor/Visualización:
activar Número de línea, esta opción es muy importante porque indica los
números de líneas del código y es muy útil porque se puede referir a los
estudiantes por el número de línea de una línea determinada.

10.-Características:

Sus principales características son las siguientes:

Uso del compilador MinGW (Minimalist GNU for Windows).

Práctico editor de código con coloreado de sintaxis, opciones de


búsqueda, reemplazar,

Gran cantidad de opciones de configuración para personalizar el


compilador, el entorno o el propio editor.

Inserción de marcadores y puntos de ruptura.

Uso de atajos de teclado.

Posibilidad de añadir, editar o eliminar herramientas.

Selección de diferentes temas para la interfaz.

11.-Algunas funciones y consideraciones importantes:

Dev-C++ es un compilador y entorno de desarrollo para el lenguaje


C/C++. Se trata de una aplicación de código abierto, que ofrece todo tipo
de facilidades para desarrollar grandes proyectos en C++. La aplicación
presenta resaltado de sintaxis, depurador, una utilidad para crear
instalaciones de nuestros programas, docenas de librerías y ficheros de
ejemplo, etc. Como opciones extra, Dev-C++ incluye múltiples idiomas
(incluido el español), explorador de clases y variables, plantillas, facilidad
para instalar librerías adicionales, etc. Todo esto sólo es una pequeña
parte de las posibilidades que se pueden encontrar en Dev-C++, un
entorno de programación verdaderamente recomendable para
desarrolladores de cualquier nivel.

Entre otras ventajas desde el punto de vista técnico se puede señalar,


que permite importar los proyectos realizados anteriormente en MS Visual
C++, se puede exportar código fuente o proyectos a HTML o RTF para
subir códigos a páginas Web y compartirlos, se pueden insertar
marcadores en el editor para desplazarse en el código rápidamente, cada
usuario puede crear su propia sintaxis coloreada, se puede configurar el
menú insertar para colocar los fragmentos de código que mas uno utilice,
permite insertar nuevos compiladores para compilar códigos fuente, tiene
una potente característica de autocompletar texto que permite aumentar
la productividad al sugerir los comandos disponibles en el contexto en
que uno se encuentra programando, tiene un explorador de clases que
muestra las clases, miembros y funciones y por otro lado la información
relevante al archivo mostrado en el editor, se pueden añadir carpetas
personales en el explorador de clases para encontrar lo que se busca en
los grande proyectos, se puede guardar un proyecto como una plantilla
de esta forma se puede comenzar a programar con una base en función
a sus necesidades.

11.-Operadores aritméticos:

son aquellos que nos van a servir para hacer las operaciones con
números, variables, etc.

12.-Operadores de asignación :

Estos operadores son comúnmente usados para las operaciones mas


rutinarias como son:

suma ( entero y decimal ) —> +

resta ( entero y decimal ) —> –


multiplicación ( entero y decimal ) —> *

división ( entero y decimal ) —> /

división para hallar el residuo ( solo para enteros ) —> %

Entonces podemos ver cuáles son los operadores aritméticos más


usados en los medios de codificación, pues hacen las operaciones más
comunes y necesarias. Ahora veremos un par de ejemplos por cada
operador:

Suma:

A = 5 + 30

Podemos ver que tenemos en éste caso dos números enteros usando un
operador aritmético ( el más ) y un operador de asignación para que la
suma se le asigne a la variable A.

M = 80.10 + 0.70

Aqui hacemos lo mismo de arriba, pero estamos trabajando con


decimales.

Z=X+Y

Aquí en cambio estamos haciéndolo directamente con variables, el valor


X y el valor Y pudieron haber sido ingresados por el usuario así ya no
son constantes como arriba el 5 , 30 , 8.10 , 0.70 a diferencia de ellos los
valores que tomara X y también Y irán cambiando con cada ejecución del
programa pues al ser diferentes usuarios que ingresen datos no
ingresaran los mismos que el usuario anterior.

Resta:

M = 800 – 400
Lo que vemos en la expresión de arriba es una resta de números enteros
que se le asigna a una variable M

M = 40.55 – 20.10

Aquí la única diferencia es que estamos restando decimales.

C=A–B

Del mismo modo que expliqué en la suma, aquí estamos restando dos
variables que pueden ser datos ingresados por el usuario y esa resta se
le asignará a C.

Multiplicación:

AA = 4 * 5

Multiplicación de dos cantidades enteras.

BB = 12.8 * 6

Multiplicación donde se involucra un valor decimal.

R=U*D

La multiplicación de las variables U y D se le asignará a R.

División:

J=5/2

Como podemos ver, estamos dividiendo dos números enteros y el


problema que viene a la mente de muchos usuarios es que dividir 5 para
2 no da un valor exacto pues 5 no es un numero par. Entonces muchos
piensan que el resultado que dará es 2.5. Pero no es así, el resultado de
la división de enteros en c++ se denota así:

Y por lo tanto vemos que al dividir 5 para 2, nos queda un valor decimal.
Pero cuando usamos la división de enteros nos da como resultado solo la
parte entera. Es decir que si tenemos esto:
5/2

La respuesta seria 2.5 , pero como estamos haciendo una división de


enteros nos dará únicamente como respuesta la parte entera. Es decir el
2 y el .5 lo dejará sin importancia pues es una división de enteros y nos
dará como resultado solo la parte entera.

A diferencia de haber hecho una división de decimales, usando el mismo


ejemplo tenemos que pudo haber sido así:

5.0 / 2Ahi nos dará como respuesta el valor 2.5 completo, pues se da
cuenta que estas haciendo una división de decimales.

Entonces el programa asimila automáticamente que lo que quieres es


una respuesta con decimales y no solamente entera, que por algo
colocaste 5.0 en vez de 5.

División para el residuo:

En el caso anterior vimos la ‖ división ‖ para enteros y decimales. Pero


ahora que vamos a ver la ‖ división para el residuo ‖ solo funciona con
números enteros. Tanto el dividendo como el divisor deben ser números
enteros, no pueden llevar decimales, Así:

A = 10 % 3 —> ¡ correcto !

Así como les decía, éste símbolo ‖ % ‖ sirve para hallar el residuo de una
división de enteros, en el caso de A que es 10 % 3 , pues el resultado
será 1. Porque 1 es el residuo ó lo que sobra en la división.
13.-Operadores logicos :

Los operadores lógicos sirven para hacer diferentes operaciones


dependiendo de lo que se proponga, por ese motivo se le califica como
que sirven para ‖ admitir / rechazar ‖ propuestas que son expresadas por
el programador o algún ejercicio / algoritmo en si.

Entro los operadores lógicos tenemos a:

OR ————- > ||

AND ————- > &&

NOT ————- > !

Con respecto a OR [ || ], significa ‖ o ―. Podemos decir en lenguaje


humano, que funciona de la siguiente manera:

Si 14 es mayor a 10 O 14 es mayor 11 entonces haga lo siguiente…

Ahora en lenguaje de código, seria de la siguiente manera:

if ( 14 > 10 || 14 > 11 )
{

........

Con respecto a AND [ && ], significa ‖ y ―. Podemos decir en lenguaje


humano, que funciona de la siguiente manera:

Si 14 es mayor a 10 Y 14 es mayor 11 entonces haga lo siguiente…

Ahora en lenguaje de código, seria de la siguiente manera:

if ( 14 > 10 && 14 > 11 )

........

}
Con respecto a NOT [ ! ], significa ‖ no / diferente que ―. Podemos decir
en lenguaje humano, que funciona de la siguiente manera:

Si 14 NO es igual a 10 entonces haga lo siguiente…

Ahora en lenguaje de código, seria de la siguiente manera:

if ( 14 != 10 )

........

14.-Librerias:

o fstream:

Flujos hacia/desde ficheros. Permite la manipulación de archivos desde

el programar, tanto leer como escribir en ellos.

o iosfwd:

Contiene declaraciones adelantadas de todas las plantillas de flujos y

sus typedefs estándar. Por ejemplo ostream.

o iostream:

Parte del a STL que contiene los algoritmos estándar, es quizá la más

usada e importante (aunque no indispensable).


o La biblioteca list:

Parte de la STL relativa a contenedores tipo list; listas doblemente

enlazadas

o math:

Contiene los prototipos de las funciones y otras definiciones para el


uso

y manipulación de funciones matemáticas.

o memory:

Utilidades relativas a la gestión de memoria, incluyendo asignadores y

punteros inteligentes (auto_ptr).

"auto_ptr" es una clase que conforma la librería memory y permite un

fácil manejo de punteros y su destrucción automaticamente.

o Biblioteca new:

Manejo de memoria dinámica

o numeric:

Parte de la librería numérica de la STL relativa a operaciones


numéricas.

o ostream:

Algoritmos estándar para los flujos de salida.

o queue:

Parte de la STL relativa a contenedores tipo queue (colas de objetos).

o Librería stdio:
Contiene los prototipos de las funciones, macros, y tipos para
manipular

datos de entrada y salida.

o Librería stdlib:

Contiene los prototipos de las funciones, macros, y tipos para


utilidades

de uso general.

o string:

Parte de la STL relativa a contenedores tipo string; una generalización

de las cadenas alfanuméricas para albergar cadenas de objetos. Muy

útil para el fácil uso de las cadenas de caracteres, pues elimina


muchas

d elas dificultades que generan los char

o typeinfo:

Mecanismo de identificación de tipos en tiempo de ejecución

o vector:

Parte de la STL relativa a los contenedores tipo vector; una

generalización de las matrices unidimensionales C/C++

o forward_list

Esta librería es útil para implementar con gran facilidad listas


enlazadas

simples.

o list
Permite implementar listas doblemente enlzadas (listas enlazadas

dobles) facilmente.

o iterator

Proporciona un conjunto de clases para iterar elementos.

o regex

Proporciona fácil acceso al uso de expresiones regulares para la

comparación de patrones.

o thread

Útil para trabajar programación multihilos y crear múltiples hilos en

nuestra aplicación.

String

string.h es un archivo de la Biblioteca estándar del lenguaje de


programación C que contiene

la definición de macros, constantes, funciones y tipos y algunas


operaciones de manipulación

de memoria.

Las funciones declaradas en string.h se han hecho muy populares, por


lo que están

garantizadas para cualquier plataforma que soporte C. Sin embargo,


existen algunos

problemas de seguridad con estas funciones, como el desbordamiento


de buffer (buffer
overflow), que hacen que algunos programadores prefieran opciones
más seguras frente a la

portabilidad que estas funciones ofrecen. Además, las funciones para


cadenas de caracteres

sólo trabajan con conjuntos de caracteres ASCII o extensiones ASCII


compatibles.
15.-Conclusión:

El Dev-C++ es un entorno de desarrollo integrado que ocupa muy poco


espacio en disco, es ideal para los cursos de iniciación a la programación
usando el lenguaje de programación C y C++, pertenece a los software
de plataformas de código abierto. Es gratuito, y su uso es muy fácil, se
puede instalar especificando el español como idioma y se pude incorporar
el manual de la biblioteca estándar de C, en conclusiones es un IDE muy
práctico para nuestras muchas circunstancias.
16.-Bibliografia:

1.- https://www.ecured.cu/Dev-C%2B%2B

2.http://www.tel.uva.es/personales/josdie/fprog/Sesiones/manualDevCpp/opci
ones_del_proyecto.html

3.- https://www.academia.edu/21168602/TUTORIAL_Dev_C_

4.- https://www.abrirllave.com/c/guia-de-uso-de-dev-c-plus-plus.phP

5.- http://www.omijal.org/pagina_c/Tutorial_DevC.pdf

6.- https://es.scribd.com/doc/41942968/Manual-Dev-C

7.- http://www.esi2.us.es/~mlm/FIQ_P/Prac_FIQ_01.pdf

8.-https://es.slideshare.net/mariconachacha/manual-del-dev-
c?from_action=sabe
17.-Anexos: