#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 "pch.h"
#include <iostream>
#include <math.h>
using namespace std;

struct complejo {
	float real, imaginario;
}num1, num2;
int main()
{
	complejo sumar(complejo a,complejo b) {
		complejo suma;
		suma.real= a.real += b.real;
		suma.imaginario=a.imaginario += b.imaginario;
		return suma;
	}
	
}

#include <iostream>
#include <math.h>
using namespace std;
struct complejo {
	float real, imaginario;
}num1, num2;
complejo sumar(complejo a,complejo b) {
	complejo suma;
	suma.real= a.real += b.real;
	suma.imaginario=a.imaginario += b.imaginario;
	return suma;
}
int main(int argc, char *argv[]) {
 
 
 
	return 0;
}
 
 

#include <iostream>
#include <math.h>
using namespace std;
struct complejo {
	float real, imaginario;
}num1, num2;
 
complejo sumar(complejo a,complejo b);
 
int main(int argc, char *argv[]) {
 
	return 0;
}
complejo sumar(complejo a,complejo b) {
	complejo suma;
	suma.real= a.real += b.real;
	suma.imaginario=a.imaginario += b.imaginario;
	return suma;
}

Alumno *p=Persona j

#include <iostream>
#include <cctype>
using namespace std;
void Todo_minuscula(string s);
int main(int argc, char *argv[]) {
	string frase="En el dia mas brillante, en la noche mas obscura, 
ningun mal escapara de mi, La luz del linterna verde!",vocal;
	/*Ahora voy a pasar todo a minuscula para que se encuentre la vocal
	sin importar si es mayuscula o minuscula*/
	Todo_minuscula(frase);
	int contador_de_vocales=0;
	cout<<"Que vocal desea ver cuantas veces aparece? "; cin>>vocal;
	/*Paso a minuscula la vocal, ya que todo esta en minuscula*/
	vocal=tolower(vocal[0]);
	//creo un auxiliar
	size_t p=frase.find(vocal,0);
	while(p!=string::npos){ //string::npos es un valor especial del metodo find...
		contador_de_vocales++;
		p=frase.find(vocal,p+vocal.size());
	}
	cout<<"Cantidad de veces que aparece la vocal "<<vocal<<": "<<contador_de_vocales;
	return 0;
}
 
void Todo_minuscula(string s){
	if(!s.empty()){
		for(size_t i=0;i<s.size();i++) { 
			s[i]=tolower(s[i]);
		}
	}
}
 

Buenas, tengo un vector de tipo "struct", y necesito leer un fichero y que me guarde los datos en un vector. Asumo que tiene que ser algo de este estilo:

Código:

        Libro libro; //es mi struct
	string nom_fichero = PracticaFinal_opcion1.libros.dat;
	
	ifstream f;
	
	f.open(nom_fichero);
	
	if (f)
	{
		while (f >> ??) // el "??" indica que no sé que poner para que lea hasta el fin del fichero. NO PUEDO USAR .eof //
		{
			//aquí irían la propia lectura
		}
	}

Gracias

struct Libro{
	/*Algun string...*/
};
int main(int argc, char *argv[]) {
	vector<Libro> V; Libro aux;
	ifstream entrada;
	entrada.open(/*Nombre del archivo*/);
	if(!entrada.is_open()){
		cerr<<"Archivo no encontrado"<<endl;
		exit(-1);
	}
	while(entrada>>aux;){
		V.push_back(aux);
	}
	entrada.close();
	return 0;
}
 

#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();
}