Pares{ float a, int b}
 
main(){
Pares aux; vector<Pares> P;
ifstream entrada;
entrada.open(/*nom_archi*/,ios::binary|ios::ate);
if(!entrada.is_open(){
 /*algo...*/
}
int tam_archi=entrada.tellg()/sizeof(Pares);
entrada.seekg(0);
for(int i=0;i=tam_archi;i++){
 entrada.read(reinterpret_cast <char*> (&aux),sizeof(aux));
 P.push_back(aux);
}
entrada.close();
fori(P.size()){
cout<<P[i].a<<" "<<P[i].b<<endl; /*No muestra nada*/
}
 

nclude <iostream>
#include <vector>
#include <fstream>
using namespace std;
 
int main(int argc, char *argv[]) {
	vector<string> p; string aux;
	ifstream entrada;
	entrada.open("Don Quijote de la mancha.pdf");
	if(!entrada.is_open()){
		cerr<<"No se abrio el archivo"<<endl;
		exit(-1);
	}
	while(getline(entrada,aux)){
		p.push_back(aux);
		entrada.ignore();
	}
	entrada.close();
	for(size_t i=0;i<p.size();i++) { 
		if(!p[i].empty()){
			aux=p[i];
			for(size_t i=0;i<aux.size();i++) { 
				aux[i]=toupper(aux[i]);
			}
			p[i]=aux;
		}
	}
	aux="MOLINOS DE VIENTO"; int contador=0;
	for(size_t i=0;i<p.size();i++) { 
		if(p[i]==aux){
			contador++;
		}
	}
	cout<<"Las palabras: "<<"Molinos de viento, aparecen un total de: "<<contador<<" veces";
	return 0;
}
 

#include <iostream>
#include <vector>
#include <sstream>
#include <fstream>
using namespace std;
struct Alumno{
	string nom_ape;
};
istream& operator>>(istream &, Alumno&);
ostream& operator<<(ostream &, Alumno&);
int Cantidad_comisiones(const int _maximo,size_t _cantidad_alum);
void Crear_listas(int, vector<Alumno>, int, int);
int Ver_cociente(int _comision, size_t _cantidad_alum); //Medio redundante...
int Alumnos_sobrantes(int _comision, size_t _cantidad_alum);
int main(int argc, char *argv[]) {
	const int maximo=30;
	vector<Alumno> V; Alumno aux;
	ifstream lectura;
	lectura.open("Unidad 5 - Nro 3 - Inscriptos.txt");
	if(!lectura.is_open()){
		cerr<<"Archivo no abierto"<<endl;
		exit(-1);
	}
	while(lectura>>aux){
		V.push_back(aux);
	}
	int comisiones=Cantidad_comisiones(maximo,V.size());
	int cociente=Ver_cociente(comisiones,V.size());
	int alumnos_sobrantes=Alumnos_sobrantes(comisiones,V.size());
	cout<<"Total de alumnos: "<<V.size()<<endl;
	cout<<"Cantidad de comisiones: "<<comisiones;
	Crear_listas(comisiones,V,cociente,alumnos_sobrantes);
	return 0;
}
istream& operator>>(istream &i, Alumno &A){
	getline(i,A.nom_ape);
	return i;
}
ostream& operator<<(ostream &o, Alumno &_A){
	o<<_A.nom_ape<<endl;
	return o;
}
int Cantidad_comisiones(const int _maximo,size_t _cantidad_alum){
	int cociente=0,resto=0;
	cociente=_cantidad_alum/_maximo;
	resto=_cantidad_alum%_maximo;
	if(resto!=0){
		return cociente+1;
	}
	return cociente;
}
int Ver_cociente(int _comision, size_t _cantidad_alum){ //Que podria hacer para no pasar todo nuevamente?
	int alumno_x_comision=_cantidad_alum/_comision;
	return alumno_x_comision;
}
int Alumnos_sobrantes(int _comision, size_t _cantidad_alum){
	float resto=_cantidad_alum%_comision;
	if(resto!=0){
		return resto*_comision;
	}
	return resto;
}
void Crear_listas(int _comisiones, vector<Alumno> _V, int _cociente,int _alum_sobrantes){
	string nom_lista="Unidad 5 - Nro 3 - Comision"; stringstream ss;
	ofstream salida;
	for(int i=0;i<_comisiones;i++) { 
		ss<<nom_lista<<i<<".txt";
		salida.open(ss.str());
		if(_alum_sobrantes!=0){
			for(int i=0;i<_cociente+1;i++) { 
				salida<<_V[i];
			}
		}else{
			for(int i=0;i<_cociente;i++) { 
				salida<<_V[i];
			}
		}
	}
	salida.close();
}

#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
using namespace std;
struct Alumno{
	string nom_ape;
	float nota1,nota2;
};
istream& operator>>(istream &i, Alumno &A){
	getline(i,A.nom_ape);
	i>>A.nota1>>A.nota2;
	i.ignore();
	return i;
}
ostream& operator<<(ostream &o, Alumno &A){
	o<<left<<A.nom_ape<<endl;
	o<<left<<A.nota1<<setfill(' ')<<setw(2)<<A.nota2<<endl;
	return o;
}
//A
void Modificar_archi(Alumno A, vector <Alumno> &D);
//B
void Promedio_archi(vector <Alumno> &D);
int main(int argc, char *argv[]) {
	vector<Alumno> V; Alumno A;
	ifstream lectura;
	lectura.open("Unidad 5 - Nro 2 - Lista.txt");
	if(!lectura.is_open()){
		cerr<<"Archivo no abierto";
		exit(-1);
	}
	while(lectura>>A){
		V.push_back(A);
	}
	lectura.close();
	//A
	cout<<"Ingrese el nombre del alumno y su apellido"<<endl; 
	getline(cin,A.nom_ape);
	cin.ignore();
	cout<<"Ahora ingrese sus dos notas"<<endl;
	cout<<"Nota 1: "; cin>>A.nota1;
	cout<<"Nota 2: "; cin>>A.nota2;
	Modificar_archi(A,V);
	//B
	Promedio_archi(V);
	return 0;
}
//A
void Modificar_archi(Alumno A, vector <Alumno> &D){
	for(size_t i=0;i<D.size();i++) { 
		if(A.nom_ape==D[i].nom_ape){
			D[i].nota1=A.nota1;
			D[i].nota2=A.nota2;
		}
	}
	ofstream escritura;
	escritura.open("Unidad 5 - Nro 2 - Lista.txt",ios::trunc);
	for(size_t i=0;i<D.size();i++) { 
		escritura<<D[i];
	}
	escritura.close();
}
//B
void Promedio_archi(vector <Alumno> &D){
	float condicion_final; Alumno aux;
	ofstream escritura;
	escritura.open("Unidad 5 - Nro 2 - Promedio.txt");
	if(!escritura.is_open()){
		cerr<<"Archivo no abierto"<<endl;
		exit (-1);
	}
	for(size_t i=0;i<D.size();i++) { 
		condicion_final=(D[i].nota1+D[i].nota2)/2;
		escritura<<D[i];
		if(condicion_final>=60){
			escritura<<"Condicion final: "<<"Aprobado"<<endl;
		}else{
			escritura<<"Condicion final: "<<"Desaprobado"<<endl;
		}
	}
	escritura.close();
}

Buenas gente, estaba haciendo un ejercicio de Racionales, 
y estaba trabajando con dos int, para representarlo respectivamente,
 mi consulta es, como podría evitar que el compilador me trunque los 
valores cuando los divido, para verlo con valor decimal?

int &operator[](int _i){ 
		if(_i<=size){
			return p[_i];
		}
		return -1;	/*Que puedo retornar para saber que supere el indice?*/
 
	}
 
cout<<"Ingrese la posicion que desea modificar: "; cin>>i;
	if(V2[i-1]==/*...*/){
		cout<<"Ha superado el tamanio del arreglo"<<endl;
	}else{
		cin>>v;
		V2[i-1]=v;
	}

a. Defina una clase Tecla para representar una tecla de un piano. Cada tecla
puede estar o no apretada, y tiene ademas una nota asociada (cuyo nombre se
representará con un string). Su interfaz debe tener tener entonces:
- un constructor que reciba el nombre de la nota
- un método VerNota que retorne el nombre de la nota
- un método Apretar que cambie el estado de la tecla a apretada.
- un método Soltar que cambie el estado de la tecla a no apretada.
- un método EstaApretada que retorne true si la tecla está apretada, false en caso
contrario
b. Defina una clase Pedal para representar el pedal de un piano. El pedal debe
almacenar un valor (f loat ) que indica la presion que el musico ejerce sobre el pedal.
El constructor debe inicializar la presion en 0 , y la clase debe tener metodos para
modificarla y consultarla.
c. Reutilizando las clases Tecla , Pedal e Instrumento :
class Instrumento{
virtual string VerTipo() { return "sin_nombre"; }
};
defina una clase Piano que modele un instrumento de tipo "piano" con solo 7 teclas
(“ do”, “re”, “mi”, “fa”, “sol”, “la” y “si” ) y 1 pedal. La clase piano debe tener métodos
para:
- apretar una tecla, indicando el numero de tecla, y que retorne la nota que debería
sonar.
- soltar una tecla, indicando el numero de tecla
- presionar el pedal, indicando la presion que se aplica

#include <iostream>
using namespace std;
class Tecla{
	string nota; int tecla;
public:
	Tecla(string _t){
		nota=_t;
	}
	string Ver_nota(){
		return nota;
	}
	void Apretar(){
		tecla=1;
	}
	void Soltar(){
		tecla=0;
	}
	bool Esta_apretada(){
		if(tecla!=0){
			return true;
		}
		return false;
	}
 
};
class Pedal{
	float presion;
public:
	Pedal(){
		presion=0;
	}
	void Aumentar_presion(float _x){
		presion=_x;
	}
	void Disminuir_presion(float _x){
		presion=_x;
	}
	float Ver_presion(){
		return presion;
	}
};
 
class Ver_Tipo{
public:
	virtual string Ver_tipo(){
		return "sin nombre";
	}
};
 
class Piano{
	Tecla *T[7]; Pedal P;
public:
	string Apretar_una_tecla(int _nro){
		T[_nro]->Apretar();
		return T[_nro]->Ver_nota();
	}
	void Soltar_una_tecla(int _nro){
		T[_nro]->Soltar();
	}
	void Presionar(float _f){
		P.Aumentar_presion(_f);
	}
 
};
int main(int argc, char *argv[]) {
	Tecla *T[7]; //No se como proseguir...
	T[0]=new Tecla ("Do");
	T[1]=new Tecla ("Re");
	T[2]=new Tecla ("Mi");
	T[3]=new Tecla ("Fa");
	T[4]=new Tecla ("Sol");
	T[5]=new Tecla ("La");
	T[6]=new Tecla ("Si");
	return 0;
}

#include <iostream>
using namespace std;
using namespace std;
struct Fecha{
	int dd,mm,aa;
};
/*
Estado civil:
-1"soltero"
0 "casado"
1 "viudo"
*/
class Persona{
	string nom_ape; int DNI, estado_civil; Fecha fecha_nacimiento;
public:
	void Cargar_datos(string _nom, int _dni, int _civil, Fecha _d_nacimiento);
	int Edad(Fecha _actual){	//retorno la edad;
		int aux=_actual.aa-fecha_nacimiento.aa;
		return aux;
	}
	string Ver_nombre(){
		return nom_ape;
	}
};
void Persona:: Cargar_datos(string _nom, int _dni, int _civil, Fecha _d_nacimiento){
	nom_ape=_nom; DNI=_dni; estado_civil=_civil; fecha_nacimiento=_d_nacimiento;
}
 
class Alumno: public Persona{
	float promedio; int cantidad_aprovadas;
public:
	void Agregar_prom(float _prom){
		promedio=_prom;
	}
	void Materias_apro(int _apro){
		cantidad_aprovadas=_apro;
	}
	float Ver_promedio(){
		return promedio;
	}
	float Merito_academico(){
		float aux=promedio*cantidad_aprovadas;
		return aux;
	}
};
 
class Docente:public Persona{
	Fecha ingreso;
public:
	void Agregar_fecha_ingreso(Fecha _f){
		ingreso=_f;
	}
	int Antiguedad(Fecha _actual){
		int aux=ingreso.aa-_actual.aa;
		return aux;
	}
};
 
class Curso{
	string nombre_curso; Docente D; Alumno *A=nullptr; int size;
public:
	Curso(int _i){
		if(_i<=50){
			size=_i;
			A=new Alumno [size];
		}else{
			cerr<<"Supero el limite maximo de alumnos (50)"<<endl;
			exit(1);
		}
 
	}
	void Agregar_docente(Docente _d){
		D=_d;
	}
	void Agregar_alumno(Alumno _a, int _i){
		A[_i]=_a;
	}
	void Nom_d_curso(string _nom){
		nombre_curso=_nom;
	}
	Alumno Mejor_promedio();
};
Alumno Curso::Mejor_promedio(){
	Alumno aux=A[0];
	for(int i=1;i<size;i++) { 
		if(aux.Ver_promedio()<A[i].Ver_promedio()){
			aux=A[i];
		}
	}
	return aux;
}
int main(int argc, char *argv[]) {
	int size; Alumno A; Docente D;
	cout<<"Ingrese la cantidad de alumnos en el curso: "; cin>>size;
	Curso C(size);
	cout<<"Seleccione la opcion para proceder :"; 
	cout<<"1	->	Agregar alumnos"<<endl;
	cout<<"2	->	Agregar Docente a cargo"<<endl;
	cout<<"Presione cualquier numero para salir del programa"<<endl;
	int caso; cin>>caso;
	switch(caso){
	case 1:
		cout<<"Ahora ingrese los datos de los alumnos:"<<endl;
		for(int i=0;i<size;i++) { 
			string nom_ape; int dni,estado_civil,materias_apro; Fecha d_nacimiento;
			float promedio; 
			cout<<"Ingrese el nombre y apellido: "; cin>>nom_ape;
			cout<<"Ingrese el DNI: "; cin>>dni;
			cout<<"Ingrese el estado civil: "; cin>>estado_civil;
			cout<<"Ingrese la fecha de nacimiento :"; 
			cin>>d_nacimiento.dd; cin>>d_nacimiento.mm; cin>>d_nacimiento.aa;
			cout<<"Ingrese el promedio del alumno :"; cin>>promedio;
			cout<<"Ingrese la cantidad de materias aprovadas: "; cin>>materias_apro;
			cout<<"-----------------------------"<<endl;
			A.Cargar_datos(nom_ape,dni,estado_civil,d_nacimiento);
			A.Materias_apro(materias_apro);
			A.Agregar_prom(promedio);
			C.Agregar_alumno(A,i);
		}
		break;
	case 2:
		cout<<"Ingrese los datos del Docente"<<endl;
		string nom_ape; int dni,estado_civil; 
		Fecha d_nacimiento, ingreso_laboral;
		cout<<"Ingrese el nombre y apellido: "; cin>>nom_ape;
		cout<<"Ingrese el DNI: "; cin>>dni;
		cout<<"Ingrese el estado civil: "; cin>>estado_civil;
		cout<<"Ingrese la fecha de nacimiento :"; 
		cin>>d_nacimiento.dd; cin>>d_nacimiento.mm; cin>>d_nacimiento.aa;
		cout<<"Ingrese la fecha de ingreso laboral :";
		cin>>ingreso_laboral.dd; cin>>ingreso_laboral.mm; cin>>ingreso_laboral.aa;
		cout<<"-------------------------------"<<endl;
		D.Cargar_datos(nom_ape,dni,estado_civil,d_nacimiento);
		D.Agregar_fecha_ingreso(ingreso_laboral);
		break;
	default: //Me da error...
		cout<<"Salio del programa"<<endl;
		break;
	}
	cout<<"El alumno con mejor promedio es: ";
	Alumno aux=C.Mejor_promedio();
	cout<<aux.Ver_nombre();
	return 0;
}

error: jump to case label [-fpermissive]

#include <iostream>
using namespace std;
struct Fecha{
	int dd,mm,aa;
};
class Fecha1{
	Fecha A;
public:
	//A
	Fecha1(int _dd,int _mm, int _aa){
		A.dd=_dd; A.mm=_mm; A.aa=_aa;
	}
	//B
	int Ver_dd();
	int Ver_mm();
	int Ver_aa();
	//C
	int Diferencia_en_anios(Fecha1 _a);
	//D
	string Signo_zodiacal();
};
int Fecha1:: Ver_dd(){
	return A.dd;
}
int Fecha1:: Ver_mm(){
	return A.mm;
}
int Fecha1:: Ver_aa(){
	return A.aa;
}
int Fecha1::Diferencia_en_anios(Fecha1 _a){
	return _a.Ver_aa()-A.aa;
}
/*
Acuario: 20 Enero – 18 Febrero.
Piscis: 19 Febrero – 20 Marzo.
Aries: 21 Marzo – 19 Abril.
Tauro: 20 Abril – 20 Mayo.
Géminis: 21 Mayo – 20 Junio.
Cáncer: 21 Junio – 22 Julio.
Leo: 23 Julio – 22 Agosto.
Virgo: 23 Agosto – 22 Septiembre
Libra: 23 Septiembre - 22 Octubre
Escorpio: 23 Octubre - 21 Noviembre
Sagitario: 22 Noviembre - 21 Diciembre
Capricornio: 22 Diciembre - 19 Enero
*/
string Fecha1::Signo_zodiacal(){
	string aux;
	switch (A.mm){
		case 1: 
			if(A.dd>=20 && A.mm>=1){
				if(A.dd<=18 && A.mm<=2){
					aux= "Acuario";
				}
			}
		break;
		case 2:
			if(A.dd>=19 && A.mm>=2){
				if(A.dd<=20 && A.mm<=3){
					aux= "Piscis";
				}
			}
		break;
		case 3:
			if(A.dd>=21 && A.mm>=3){
				if(A.dd<=19 && A.mm<=4){
					aux= "Aries";
				}
			}
		break;
		case 4:	
			if(A.dd>=20 && A.mm>=4){
				if(A.dd<=20 && A.mm<=5){
					aux= "Tauro";
				}
			}
		break;
		case 5:
			if(A.dd>=21 && A.mm>=5){
				if(A.dd<=20 && A.mm<=6){
					aux= "Geminis";
				}
			}
		break;
		case 6:	
			if(A.dd>=21 && A.mm>=6){
				if(A.dd<=22 && A.mm<=7){
					aux= "Cancer";
				}
			}
		break;
		case 7:
			if(A.dd>=23 && A.mm>=7){
				if(A.dd<=22 && A.mm<=8){
					aux= "Leo";
				}
			}
		break;
		case 8:
			if(A.dd>=23 && A.mm>=8){
				if(A.dd<=22 && A.mm<=9){
					aux= "Virgo";
				}
			}
		break;
		case 9:
			if(A.dd>=23 && A.mm>=9){
				if(A.dd<=22 && A.mm<=10){
					aux= "Libra";
				}
			}
			break;
		case 10:	
			if(A.dd>=23 && A.mm>=10){
				if(A.dd<=21 && A.mm<=11){
					aux= "Escorpio";
				}
			}
			break;
		case 11:
			if(A.dd>=22 && A.mm>=11){
				if(A.dd<=21 && A.mm<=12){
					aux= "Sagitario";
				}
			}
			break;
		case 12:
			if(A.dd>=22 && A.mm>=12){
				if(A.dd<=19 && A.mm<=1){
					aux= "Capricornio";
				}
			}
		break;
	}
	return aux;
}
int main(int argc, char *argv[]) {
	Fecha1 A(29,2,1996),B(30,5,2018);
	cout<<"Edad: "<<A.Diferencia_en_anios(B)<<endl; 
	cout<<"Su signo es: "<<A.Signo_zodiacal(); //No muestra el signo......
	return 0;
}

P_resuesta=P1.Sumar(P2)

#include <iostream>
#include <cmath>
using namespace std;
class Polinomio{
	int coeficiente[20]; int grado;
public:
	Polinomio(int _grado=0){
		grado=_grado;
		for(int i=0;i<grado;i++) { 
			coeficiente[i]=0;
		}
	};
	int Ver_coeficientes(int _i){
		return coeficiente[_i];
	}
	void Cambiar_coeficiente(int _c, int _pos);
	Polinomio Sumar_polinomios(Polinomio p2); 
	int Evaluar(int _x);
 
 
};
void Polinomio::Cambiar_coeficiente(int _c, int _pos){
	coeficiente[_pos]=_c;
}
Polinomio Polinomio:: Sumar_polinomios(Polinomio p2){
	for(int i=0;i<grado;i++) { 
		coeficiente[i]+=p2.Ver_coeficientes(i); //Que deberia retornar?
	}
}
int Polinomio::Evaluar(int _x){
	int aux=0;
	for(int i=0;i<grado--;i++) { 
		aux+=coeficiente[i]*(pow(_x,(grado-i)));
	}
	aux+=coeficiente[grado];
	return aux;
}
int main(int argc, char *argv[]) {
	int size; int coeficiente;
	cout<<"Ingrese el grado del Polinomio: "; cin>>size;
	Polinomio P(size); 
	/*Carga del polinomio*/
	cout<<"Ingrese los coeficientes, de mayor grado a menor "; cin>>coeficiente;
	int i=0;
	while(i<size){
		P.Cambiar_coeficiente(coeficiente,i);
		cout<<"Ingrese los coeficientes, de mayor grado a menor "; cin>>coeficiente;
		++i;
	}
	/*Veamos la carga inicial*/
	for(int i=0;i<size;i++) { 
		cout<<P.Ver_coeficientes(i)<<"x^"<<size-i; //Por que no veo el termino independiente?
	} 
	cout<<endl;
	/*Evaluemos con un valor x el polinomio*/
	int x; 
	cout<<"Ingrese la incognita: "; cin>>x;
	cout<<P.Evaluar(x); //Obtengo basura, por que?
	cout<<endl;
	/*Probemos el metodo sumar Polinomio*/
	/* nada*/