PROYECTO FINAL

CPA Program. Essentiasl C++

Implementa Colección de Estructuras

 Implementa estructura de arrays

Pudiésemos declarar un array de esa estructura en cualquier parte del programa, por
ejemplo: Persona clientes.Ahora tenemos un array que contiene tres elementos, y cada
elemento, contiene dentro de sí todos los datos con los cuales ha sido declarada la
estructura: Nombre, apellido y edad.

#include "iostream"

using namespace std;

int main()
{
char titulos [5];
char autores [5];
cout << "Por favor ingrese la siguiente información de los Libros: \n";
for (int i = 0; i < 5; i++)
{
cout << "\n******* Libro " << i + 1 <<"********:\n";
cout << "Titulo: ";
cin >> titulos[i];
cout << "Autor: ";
cin >> autores[i];
}
}
  Implementa contenedores dinámicos (Vector, queue stack)

La biblioteca de contenedores es una colección genérica de plantillas de clase que

permiten a los programadores implementar estructuras de datos comunes fácilmente,
como colas, listas y pilas. Hay tres clases de contenedores - contenedores de secuencias,
contenedores asociativos y contenedores asociativos desordenados - cada uno de los
cuales está diseñado para dar soporte a un conjunto diferente de operaciones.

#include <cstdlib>
#include <iostream>
#include <vector>

using namespace std;

int main(int argc, char *argv[])

{
char buffer [80];
double suma;
vector<double> v;

v.push_back(999.25);
v.push_back(888.50);
v.push_back(777.25);

suma = 0;
for (int i = 0; i < v.size(); i++)
{
suma += v[i];
sprintf(buffer, "%10.2f", v[i]);
cout << buffer << endl;
}

cout << "----------" << endl;

sprintf(buffer, "%10.2f", suma);
cout << buffer << endl;

cin.get();
return EXIT_SUCCESS;
}

 implementa adaptadores de contenedores priority_queue - montículos

cualquier tipo de objeto (hay algunas restricciones). Existen 3 tipos de clases contenedoras: contenedores de primera
clase, adaptadores y casi-contenedores.
También podemos catalogar a los contenedores por el tipo. Existen 3 tipos de contenedores: Contenedores de
secuencia, Contenedores asociativos y Adaptadores de contenedores. Vamos a ver una tabla con los tipos de
contenedores que hay.

#pragma warning(disable:4786)
#include "stdafx.h"
#include <queue>
#using <mscorlib.dll>
#if _MSC_VER > 1020
using namespace std;
#endif
using namespace System;
class Student {
public:
char* chName;
int nAge;
Student(): chName(""),nAge(0){}
Student( char* chNewName, int nNewAge ):chName(chNewName), nAge(nNewAge){}
};
bool operator< (const Student& structstudent1, const Student &structstudent2)
{
return structstudent1.nAge > structstudent2.nAge;
}
bool operator> (const Student& structstudent1, const Student &structstudent2)
{
return structstudent1.nAge < structstudent2.nAge;
}
int _tmain()
{
priority_queue<Student, vector<Student>,less<vector<Student>::value_type> > pqStudent1;
priority_queue<Student, vector<Student>,greater<vector<Student>::value_type> > pqStudent2;
pqStudent1.push( Student( "Mark", 38 ) );
pqStudent1.push( Student( "Marc", 25 ) );
pqStudent1.push( Student( "Bill", 47 ) );
pqStudent1.push( Student( "Andy", 13 ) );
pqStudent1.push( Student( "Newt", 44 ) );
while ( !pqStudent1.empty() ) {
cout << pqStudent1.top().chName << endl;
pqStudent1.pop();
}
cout << endl;
pqStudent2.push( Student( "Mark", 38 ) );
pqStudent2.push( Student( "Marc", 25 ) );
pqStudent2.push( Student( "Bill", 47 ) );
pqStudent2.push( Student( "Andy", 13 ) );
pqStudent2.push( Student( "Newt", 44 ) );
while ( !pqStudent2.empty() ) {
cout << pqStudent2.top().chName << endl;
pqStudent2.pop();
}
cout << endl;

return 0;
}

Implementa Arreglos asociativos

 diseña métodos de acceso a valores

Se trata de pequeñas funciones que le permiten leer o cambiar parte del estado de un objeto, es
decir, una o varias variables internas. La razón por la que inline es tan importante para las
funciones de acceso se puede ver en el siguiente ejemplo:

class Access {
 int i;
public:
int read() const { return i; }
void set(int ii) { i = ii; }
};

int main() {
Access A;
A.set(100);
int x = A.read();
} ///:~

 implementa método común de acceso insert, count, find

insert(i, x)
Inserta un ítem en una posición dada. El primer argumento es el índice del ítem delante del cual se
insertará, por lo tanto a.insert(0, x) inserta al principio de la lista, y a.insert(len(a), x) equivale a
a.append(x)

// set::count
#include <iostream>
#include <set>

int main ()
{
std::set<int> myset;

// set some initial values:

for (int i=1; i<5; ++i) myset.insert(i*3); // set: 3 6 9 12

for (int i=0; i<10; ++i)

{
std::cout << i;
if (myset.count(i)!=0)
std::cout << " is an element of myset.\n";
else
std::cout << " is not an element of myset.\n";
}

return 0;

 implementa método set y multiset

*Un set , el valor de retorno puede ser solo 0 o 1. Usando los mismos
valores que arriba, tendremos:

*En el caso de std::multiset , puede haber varios elementos que tengan el

mismo valor. Para obtener este rango, se puede usar la función
equal_range() . Devuelve std::pair con iterador límite inferior (inclusivo) y
límite superior (exclusivo) respectivamente.

std::set<int> sut;
sut.insert(10);
sut.insert(15);
sut.insert(22);
sut.insert(3); // contains 3, 10, 15, 22

auto itS = sut.find(10); // the value is found, so *itS == 10

itS = sut.find(555); // the value is not found, so itS == sut.end()

std::multiset<int> msut;
sut.insert(10);
sut.insert(15);
sut.insert(22);
sut.insert(15);
sut.insert(3); // contains 3, 10, 15, 15, 22

auto itMS = msut.find(10);

 implementa método de existencia map y multipat

map es un contenedor asociativo para contener en orden una

lista de parejas de valores únicos asociados como clave/valor.
En orden de poder crear objetos maps en nuestros programas deberemos incluir
el uso de la clase map mediante la expresion: #include <map>

#include <iostream>
#include <string>
#include <utility>
#include <map>
#include <iomanip>

using namespace std;

/*----------------------------------------*/
typedef pair<string, double> venta_dia;

int main()
{
cout << "\nUna simple prueba de map\n";
cout << "........................\n";
map<string, double> semana;

semana.insert( venta_dia("lunes", 300.65) );

semana.insert( venta_dia("martes", 456.12) );
semana.insert( venta_dia("miercoles", 234.56) );
double total = 0;

map<string, double>::iterator p = semana.begin();

while (p != semana.end() )
{
cout << setw(10) << p->first << setw(12) << p->second << endl;
total += p->second;
p ++;
}

cout << "........................\n";

cout << setw(10) << "total:" << setw(12) << total << endl;

system("pause");
return 0;
}

Crea colecciones para el procesamiento de datos

 implementa for_each

Aplica la función f objeto especificado en el resultado de la eliminación de

referencias a cada iteración de la [first, last) rango, en orden. Si InputIt es un
iterador mutable, f podrá modificar los elementos de la serie a través del
repetidor sin referencia. Si f devuelve un resultado, el resultado es ignorado .
Original:

#include <vector>
#include <algorithm>
#include <iostream>
 struct Sum {
Sum() { sum = 0; }
void operator()(int n) { sum += n; }

int sum;
};

int main()
{
std::vector<int> nums{3, 4, 2, 9, 15, 267};

std::cout << "before: ";

for (auto n : nums) {
std::cout << n << " ";
}
std::cout << '\n';

std::for_each(nums.begin(), nums.end(), [](int &n){ n++; });

Sum s = std::for_each(nums.begin(), nums.end(), Sum());

std::cout << "after: ";

for (auto n : nums) {
std::cout << n << " ";
}
std::cout << '\n';
std::cout << "sum: " << s.sum << '\n';
}

 implementa funciones mismatch, equal

Regrese la primera posición donde difieren dos rangos

Compara los elementos en el rango [first1, last1) con los del rango que comienzan en
first2 , y devuelve el primer elemento de ambas secuencias que no coincide.

Los elementos se comparan usando operator==(o pred , en la versión (2) ).

La función devuelve unparde iteradores al primer elemento en cada rango que no

coincide.

Mismatch ejemplo:
#include <iostream> // std::cout
#include <algorithm> // std::mismatch
#include <vector> // std::vector
#include <utility> // std::pair

bool mypredicate (int i, int j) {

 return (i==j);
}

int main () {
std::vector<int> myvector;
for (int i=1; i<6; i++) myvector.push_back (i*10); // myvector: 10 20 30 40 50

int myints[] = {10,20,80,320,1024}; // myints: 10 20 80 320 1024

std::pair<std::vector<int>::iterator,int*> mypair;

// using default comparison:

mypair = std::mismatch (myvector.begin(), myvector.end(), myints);
std::cout << "First mismatching elements: " << *mypair.first;
std::cout << " and " << *mypair.second << '\n';

++mypair.first; ++mypair.second;

// using predicate comparison:

mypair = std::mismatch (mypair.first, myvector.end(), mypair.second, mypredicate);
std::cout << "Second mismatching elements: " << *mypair.first;
std::cout << " and " << *mypair.second << '\n';

return 0;
}

Equal ejemplo:
#include <iostream> // std::cout
#include <algorithm> // std::equal
#include <vector> // std::vector

bool mypredicate (int i, int j) {

return (i==j);
}

int main () {
int myints[] = {20,40,60,80,100}; // myints: 20 40 60 80 100
std::vector<int>myvector (myints,myints+5); // myvector: 20 40 60 80 100

// using default comparison:

if ( std::equal (myvector.begin(), myvector.end(), myints) )
std::cout << "The contents of both sequences are equal.\n";
else
std::cout << "The contents of both sequences differ.\n";

myvector[3]=81; // myvector: 20 40 60 81 100

 // using predicate comparison:
if ( std::equal (myvector.begin(), myvector.end(), myints, mypredicate) )
std::cout << "The contents of both sequences are equal.\n";
else
std::cout << "The contents of both sequences differ.\n";

return 0;
}

 implementa función min_element y max_element

Devuelve un iterador que apunta al elemento con el valor más pequeño en el rango [first,last).

Las comparaciones se realizan ya sea operator<para la primera versión o comp para la segunda;
Un elemento es el más pequeño si ningún otro elemento se compara menos que él. Si más de un
elemento cumple esta condición, el iterador devuelve puntos al primero de dichos elementos.

#include <iostream> // std::cout

#include <algorithm> // std::min_element, std::max_element

bool myfn (int i, int j) {return i<j;}

struct myclass {
bool operator () (int i, int j) {return i<j;}
} myobj;

int main () {
int myints[] = {3,7,2,5,6,4,9};

// using default comparison:

std::cout << "The smallest element is " << *std::min_element(myints,myints+7) << '\n';
std::cout << "The largest element is " << *std::max_element(myints,myints+7) << '\n';
 // using function myfn as comp:
std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myfn) << '\n';
std::cout << "The largest element is " << *std::max_element(myints,myints+7,myfn) << '\n';

// using object myobj as comp:

std::cout << "The smallest element is " << *std::min_element(myints,myints+7,myobj) << '\n';
std::cout << "The largest element is " << *std::max_element(myints,myints+7,myobj) << '\n';

return 0;
}

Implementa operaciones entre conjunto de colecciones

 implementa algoritmos de fusión

Para reconocer las ejecuciones en el rango de entrada. Una ejecución es una subsecuencia contigua que es
ascendente o estrictamente descendente.

#include <algorithm>
#include <chrono>
#include <iostream>
#include <random>

#include "natural_merge_sort.h"

/*******************************************************************************
* Prints an array. *
*******************************************************************************/
template<class T>
static void print_int_array(const T* begin, const T* last)
{
while (begin < last)
{
std::cout << *begin++ << " ";
}

std::cout << std::endl;

}
/*******************************************************************************
* Checks that the input range is sorted (is in ascending order). *
*******************************************************************************/
template<class T, class Cmp>
bool is_sorted(T* begin, T* end, Cmp cmp)
{
while (begin < end - 1)
{
if (cmp(*(begin + 1), *begin))
{
return false;
}

++begin;
}

return true;
}

 crea funciones de mínimo y máximo elemento.

Maximo:

#include
#include
#include

int main()
{
std::vector v{3, 1, 4, 1, 5, 9};

std::vector::iterator result = std::max_element(std::begin(v), std::end(v));

std::cout << "Maximo en la posicion: " << std::distance(std::begin(v), result);
}

Mínimo:

#include
#include
#include

int main()
{
std::vector v{3, 1, 4, 1, 5, 9};

std::vector::iterator result = std::min_element(std::begin(v), std::end(v));

std::cout << "Minimo en la posicion: " << std::distance(std::begin(v), result);
}
 Implementa formatos de salida
 implementa función put

La función puts se usa para escribir una secuencia de caracteres al flujo de salida estándar:

#include <stdio.h>
int *puts(const char *s);

s se refiere al array que contiene la cadena de caracteres. Si la función se realiza correctamente, devuelve
0. Si no, devuelve algo distinto de cero.

El siguiente programa muestra un ejemplo del funcionamiento de gets y puts.

#include <stdio.h>
#define TAM_MAXIMO 80
0
int main(void)
{
char cadena[TAM_MAXIMO];

printf("Por favor, escribe una línea de no más de 80 caracteres:\n");

gets(cadena);
printf("La línea que has introducido es:\n");
puts(cadena);
return 0;
}
  crea formato de salida simple
Un programa en C++ puede realizar operaciones de entrada y salida de varias formas distintas.
A continuación, describiremos lo que se conoce como flujos. Un flujo de entrada no es más que
la serie de entradas que alimentan un ordenador para que el programa las utilice. En esta sección
supondremos que la entrada proviene del teclado. Asimismo, un flujo de salida es la serie de
salidas que el programa genera. En esta sección supondremos que las salidas se envían a la
pantalla de un terminal.
#include <stdio.h>

Int main () {
Int i;
Float x;
Printf(“teclee el numero entero i /n”);
Sacnf(“%d”,&i);
Printf(“teclee el número real x /n”);
Scanf(“%f”,&x);

Return 0;

Implementa manipuladores mediante funciones

Para dar formato a los datos que se muestran por pantalla, C++ asocia con el stream de
salida un conjunto de manipuladores que permiten modificar la forma en la que son
visualizados los resultados.
 Un manipulador equivale a una llamada a una función.
 Algunos de los manipuladores más comunes son los siguientes:
 dec conversión a decimal
 hex conversión a hexadecimal
 oct conversión a octal
 skipws extrae un espacio en blanco inicial
 endl se imprime un ‘\n’ y se vacía el buffer de salida
 flush se vacía el buffer de salida
 setw(int w) establece la anchura mínima de campo
 setprecision(int p) establece el número de cifras significativas, por defecto 6.
 setfill(char ch) establece el carácter de relleno
 left la salida se alinea a la izquierda
 rigth la salida se alinea a la derecha
 internal se alinea el signo y los caracteres indicativos de la base por la izquierda
y las cifras por la derecha
 showbase se muestra la base de los valores numéricos
 showpoint se muestra el punto decimal
 uppercase los caracteres de formato aparecen en mayúsculas
 showpos se muestra el signo (+) en los valores positivos
 scientific notación científica para coma flotante
 fixed notación normal de C++ para coma flotante
 setiosflag(long i) establece una lista de flags de formato
 resetriosflag(long i) suprime una lista de flags de formato