Pętla licząca wartość

#include <iostream>
#include <string>
#include <fstream>
#include <conio.h>

using namespace std;

class Pracownik
{
	int id_pracownika, rok_zatrudnienia;
	string nazwisko;
public:
	Pracownik()
	{
		id_pracownika = 0;
		nazwisko = " ";
		rok_zatrudnienia = 0;
	}
	Pracownik(int id_pracownika, string nazwisko, int rok_zatrudnienia)
	{
		this->id_pracownika = id_pracownika;
		this->nazwisko = nazwisko;
		this->rok_zatrudnienia = rok_zatrudnienia;
	}

	int daj_id_pracownika()
	{
		return id_pracownika;
	}

	string daj_nazwisko()
	{
		return nazwisko;
	}

	int daj_rok_zatrudnienia()
	{
		return rok_zatrudnienia;
	}
};

class Produkt
{
	int id_produktu;
	string nazwa_produktu;
	float cena_produktu;
public:
	Produkt()
	{
		id_produktu = 0;
		nazwa_produktu = " ";
		cena_produktu = 0;
	}
	Produkt(int id_produktu, string nazwa_produktu, float cena_produktu)
	{
		this->id_produktu = id_produktu;
		this->nazwa_produktu = nazwa_produktu;
		this->cena_produktu = cena_produktu;
	}
	int daj_id_produktu()
	{
		return id_produktu;
	}
	string daj_nazwa_produktu()
	{
		return nazwa_produktu;
	}
	float daj_cena_produktu()
	{
		return cena_produktu;
	}
};

class Sprzedaz
{
	int id_pracownika, id_produktu, ilosc_sprzedanych;
public:
	Sprzedaz()
	{
		id_pracownika = 0;
		id_produktu = 0;
		ilosc_sprzedanych = 0;
	}
	Sprzedaz(int id_pracownika, int id_produktu, int ilosc_sprzedanych)
	{
		this->id_pracownika = id_pracownika;
		this->id_produktu = id_produktu;
		this->ilosc_sprzedanych = ilosc_sprzedanych;
	}
	int daj_id_pracownika()
	{
		return id_pracownika;
	}
	int daj_id_produktu()
	{
		return id_produktu;
	}
	int daj_ilosc_sprzedanych()
	{
		return ilosc_sprzedanych;
	}
};

int main()
{
/////////////////////////
//*Początek Pracownik*//
////////////////////////
//Zmienne
	string nazwisko;
	int id_pracownika, rok_zatrudnienia, liczba_pracownikow = 0;
	char*nazwa_pliku = "C:\\Pracownik.txt";
	Pracownik tprac[100], tprac1[100];

//Zapisywanie danych o pracowniku do tablicy "tprac"
	for (;;)
	{
		cout << "Zeby dodac pracownika wcisnij d." << endl;
		if (_getch() != 'd')break;
		cout << "Podaj dane pracownika (id pracownika, nazwisko, rok zatrudnienia): " << endl;
		cin >> id_pracownika >> nazwisko >> rok_zatrudnienia;
		Pracownik tmp(id_pracownika, nazwisko, rok_zatrudnienia);
		tprac[liczba_pracownikow] = tmp;
		liczba_pracownikow++;
		cout << endl;
	}

//Dopisywanie do pliku Pracownik.txt zawartosci tablicy "tprac" rekordami - id, nazwisko, rok
	ofstream dopliku(nazwa_pliku, ios_base::app);
	for (int i = 0; i < liczba_pracownikow; i++)
	{
		dopliku << tprac[i].daj_id_pracownika() << " " << tprac[i].daj_nazwisko() << " " << tprac[i].daj_rok_zatrudnienia() << endl;
	}
	dopliku.close();

//Odczyt danych z pliku do tablicy tprac1
	ifstream zpliku(nazwa_pliku);
	for (;;)
	{
		if (!(zpliku >> id_pracownika))
		{
			break;
		}
		zpliku >> nazwisko >> rok_zatrudnienia;
		Pracownik tmp(id_pracownika, nazwisko, rok_zatrudnienia);
		tprac1[liczba_pracownikow] = tmp;
		liczba_pracownikow++;
	}
	zpliku.close();
	cout << endl;
////////////////////////
//*Koniec Pracownika*//
///////////////////////

///////////////////////
//*Początek Produkt*//
//////////////////////
//Zmienne
	int id_produktu, liczba_produktow = 0;
	string nazwa_produktu;
	float cena_produktu;
	char*nazwa_pliku1 = "C:\\Produkty.txt";
	Produkt tprod[100], tprod1[100];

//Zapisywanie danych o produktach do tablicy "tprod"
	for (;;)
	{
		cout << "Zeby dodac produkt wcisnij d." << endl;
		if (_getch() != 'd')break;
		cout << "Podaj dane produktu (id produktu, nazwa produktu, cena produktu): " << endl;
		cin >> id_produktu >> nazwa_produktu >> cena_produktu;
		Produkt tmp1(id_produktu, nazwa_produktu, cena_produktu);
		tprod[liczba_produktow] = tmp1;
		liczba_produktow++;
		cout << endl;
	}

//Dopisywanie do pliku Produkty.txt zawartosci tablicy "tprod" rekordami - id, nazwa, cena
	ofstream dopliku1(nazwa_pliku1, ios_base::app);
	for (int i = 0; i < liczba_produktow; i++)
	{
		dopliku1 << tprod[i].daj_id_produktu() << " " << tprod[i].daj_nazwa_produktu() << " " << tprod[i].daj_cena_produktu() << endl;
	}
	dopliku1.close();

//Odczyt danych z pliku do tablicy tprod1
	ifstream zpliku1(nazwa_pliku1);
	for (;;)
	{
		if (!(zpliku1 >> id_produktu))
		{
			break;
		}
		zpliku1 >> nazwa_produktu >> cena_produktu;
		Produkt tmp(id_produktu, nazwa_produktu, cena_produktu);
		tprod1[liczba_produktow] = tmp;
		liczba_produktow++;
	}
	zpliku1.close();
	cout << endl;
//////////////////////
//*Koniec Produktu*//
/////////////////////

////////////////////////
//*Początek Sprzedaz*//
///////////////////////
//Zmienne
	int  id_pracownika_a, id_produktu_a, ilosc_sprzedanych, liczba_sprzedazy = 0;
	char*nazwa_pliku2 = "C:\\Sprzedaz.txt";
	Sprzedaz ts[100], ts1[100];

//Zapisywanie danych o sprzedazy do tablicy "ts"
	for (;;)
	{
		cout << "Zeby dodac sprzedaz wcisnij d." << endl;
		if (_getch() != 'd')break;
		cout << "Podaj dane sprzedazy (id pracownika, id produktu, ilosc sprzedanych sztuk): " << endl;
		cin >> id_pracownika_a >> id_produktu_a >> ilosc_sprzedanych;
		Sprzedaz tmp2(id_pracownika_a, id_produktu_a, ilosc_sprzedanych);
		ts[liczba_sprzedazy] = tmp2;
		liczba_sprzedazy++;
		cout << endl;
	}

//Dopisywanie do pliku Sprzedaz.txt zawartosci tablicy "ts" rekordami - id, id, ilosc
	ofstream dopliku2(nazwa_pliku2, ios_base::app);
	for (int i = 0; i < liczba_sprzedazy; i++)
	{
		dopliku2 << ts[i].daj_id_pracownika() << " " << ts[i].daj_id_produktu() << " " << ts[i].daj_ilosc_sprzedanych() << endl;
	}
	dopliku2.close();

//Odczyt danych z pliku do tablicy ts1
	ifstream zpliku2(nazwa_pliku2);
	for (;;)
	{
		if (!(zpliku2 >> id_pracownika))
		{
			break;
		}
		zpliku2 >> id_produktu >> ilosc_sprzedanych;
		Sprzedaz tmp2(id_pracownika, id_produktu, ilosc_sprzedanych);
		ts1[liczba_sprzedazy] = tmp2;
		liczba_sprzedazy++;
	}
	zpliku2.close();
	cout << endl;
///////////////////////
//*Koniec Sprzedazy*//
//////////////////////

//Wyswietlanie plikow Pracownik, Produkt i Sprzedaz
	cout << "Lista pracownikow:" << endl;
	for (int i = 0; i < liczba_pracownikow; i++)
	cout << "Id pracownika: " << tprac1[i].daj_id_pracownika() << ", Nazwisko: " << tprac1[i].daj_nazwisko() << ", Rok zatrudnienia: " << tprac1[i].daj_rok_zatrudnienia() << endl;
	cout << endl;

	cout << "Lista produktow:" << endl;
	for (int i = 0; i < liczba_produktow; i++)
	cout << "Id produktu: " << tprod1[i].daj_id_produktu() << ", Nazwa produktu: " << tprod1[i].daj_nazwa_produktu() << ", Cena produktu: " << tprod1[i].daj_cena_produktu() << " zl" << endl;
	cout << endl;

	cout << "Lista sprzedazy:" << endl;
	for (int i = 0; i < liczba_sprzedazy; i++)
	cout << "Id pracownika: " << ts1[i].daj_id_pracownika() << ", Id produktu: " << ts1[i].daj_id_produktu() << ", Ilosc sprzedanych sztuk: " << ts1[i].daj_ilosc_sprzedanych() << endl;
	cout << endl;


///Nazwiska pracowników zatrudnionych przez okres krótszy, niż 5 lat.
	cout << "1" << endl;
	cout << "Nazwiska pracownikow zatrudnionych przez okres krotszy, niz 5 lat:" << endl << endl;
	for (int i = 0; i < liczba_pracownikow; i++)
	if (tprac1[i].daj_rok_zatrudnienia() > 2011)
	{
		cout << "- " << tprac1[i].daj_nazwisko() << endl;
	}
	cout << endl;

//Łączną wartość produktów sprzedanych przez wskazanego pracownika.
	**string pracownik;
	int id_prac, id_prod;
	float cena_prod, laczna_wartosc, laczna_wartosc1 = 0;
	double laczna_wartosc2;
	cout << "2" << endl;
	cout << "Podaj nazwe pracownika do wskazania lacznej wartosci sprzedanych produktow: "; cin >> pracownik;
	for (int i = 0; i < liczba_pracownikow; i++)
		if (pracownik == tprac1[i].daj_nazwisko())
			id_prac = tprac1[i].daj_id_pracownika();
		for (int i = 0; i < liczba_sprzedazy; i++)
		if (id_prac == ts1[i].daj_id_pracownika())
			id_prod = ts1[i].daj_id_produktu();
			for (int i = 0; i < liczba_produktow; i++)
			if (id_prod == tprod1[i].daj_id_produktu())
				cena_prod = tprod1[i].daj_cena_produktu();
			for (int i = 0; i < liczba_sprzedazy; i++)
			if (id_prod = ts1[i].daj_id_produktu())
				laczna_wartosc = cena_prod * ts1[i].daj_ilosc_sprzedanych(); 
		
			laczna_wartosc1 += laczna_wartosc;
	cout << "Laczna wartosc produktow sprzedanych przez wskazanego pracownika:" << laczna_wartosc1 << endl;**

system("Pause");
}

string pracownik;
	int id_prac, id_prod;
	float cena_prod, laczna_wartosc, laczna_wartosc1 = 0;
	double laczna_wartosc2;
	cout << "Zadanie 2" << endl;
	cout << "Podaj nazwe pracownika do wskazania lacznej wartosci sprzedanych produktow: "; cin >> pracownik;
	for (int i = 0; i < liczba_pracownikow; i++)// Petla wczytujaca dane pracownikow
	{
		if (pracownik == tprac1[i].daj_nazwisko())
		{
			id_prac = tprac1[i].daj_id_pracownika(); 
			for (int i = 0; i < liczba_sprzedazy; i++)
			{
				if (id_prac == ts1[i].daj_id_pracownika())
				{
					id_prod = ts1[i].daj_id_produktu();
					for (int i = 0; i < liczba_produktow; i++)
					{
						if (id_prod == tprod1[i].daj_id_produktu())
						{
							cena_prod = tprod1[i].daj_cena_produktu();
							for (int i = 0; i < liczba_sprzedazy; i++)
							{
								if (id_prod = ts1[i].daj_id_produktu())
								{
									laczna_wartosc = cena_prod * ts1[i].daj_ilosc_sprzedanych(); 
								}
							}
						}
					}
				}
			}
		}
	}
			laczna_wartosc1 += laczna_wartosc;
	cout << "Laczna wartosc produktow sprzedanych przez wskazanego pracownika: " << laczna_wartosc1 << " zl" << endl;

#pragma once

template<class Cont>
struct id {
    using type = typename Cont::size_type;
    type value;
};

#pragma once
#include <string>
#include <vector>

namespace schema {
    //NEVER use floating point types for currency in production code.
    using currency_t = float;

    struct product {
        std::string name;
        currency_t currency;
    };
}

namespace table {
    using products = std::vector<schema::product>;
}

#pragma once
#include <string>
#include <vector>

namespace schema {
    struct employee {
        std::string name;
        int employment_year;
    };
}

namespace table {
    using employees = std::vector<schema::employee>;
}

#pragma once
#include <vector>

#include "employee.hpp"
#include "product.hpp"
#include "id.hpp"

namespace schema {
    struct transaction {
        id<table::employees> employee_id;
        id<table::products> product_id;
    };
}

namespace table {
    using transactions = std::vector<schema::transaction>;
}

#pragma once

#include "employee.hpp"
#include "transaction.hpp"
#include "product.hpp"

struct database {
    table::employees employees;
    table::products products;
    table::transactions transactions;
};

#pragma once
#include <iostream>

#include "database.hpp"

namespace view {
    void all_employees(database &db, std::ostream &os = std::cout);
}

#include "views.hpp"

namespace view {
    void all_employees(database &db, std::ostream &os) {
        const auto &employees = db.employees;
        for(size_t id = 0; id < employees.size(); ++id) {
            const auto &employee = employees[id];
            os << "(employee)\n"
               << "id: " << id << ", "
               << "name: \"" << employee.name << "\", "
               << "employment year: " << employee.employment_year << "\n";
        }
    }
}

#include "database.hpp"
#include "views.hpp"

int main() {
    using namespace table;
    using namespace schema;
    database db = {
        employees {
            employee { "Jan Kowalski", 2001 },
            employee { "Adam Sosna", 2012 },
            employee { "Janusz Podlaski", 2013 }
        },
        products {
            product { "mleko", 2.f },
            product { "kielbasa", 9.f },
            product { "wungiel", 600.f }
        },
        transactions {}
    };
    
    view::all_employees(db);
    
    return 0;
}

(employee)
id: 0, name: "Jan Kowalski", employment year: 2001
(employee)
id: 1, name: "Adam Sosna", employment year: 2012
(employee)
id: 2, name: "Janusz Podlaski", employment year: 2013

laczna_wartosc = cena_prod * ts1[i].daj_ilosc_sprzedanych(); 

laczna_wartosc1 += laczna_wartosc; 

namespace schema {
    using quantity = size_t;
    struct transaction {
        id<table::employees> employee_id;
        id<table::products> product_id;
        schema::quantity quantity;
    };
}

#pragma once

template<class Cont>
struct id {
    using type = typename Cont::size_type;
    type value;
    
    friend bool operator==(id<Cont> lhs, id<Cont> rhs) {
        return lhs.value == rhs.value;
    }
};

namespace schema {
    //NEVER use floating point types for currency in production code.
    using currency = float;

    struct product {
        std::string name;
        schema::currency price;
    };
}

#include <algorithm>
#include <iostream>

#include "database.hpp"
#include "views.hpp"

//sadly, wandbox cannot handle multiple cpp files
#include "views.cpp"

using schema::currency;

template<typename Iterator, typename Pred, typename Operation> 
void for_each_if(Iterator begin, Iterator end, Pred p, Operation op) {
    for(; begin != end; begin++) {
        if (p(*begin)) {
            op(*begin);
        }
    }
}
    
//PS. one could refactor these inserts
auto insert(database &db, const schema::employee &employee) {
    auto identifier = id<table::employees> { db.employees.size() };
    db.employees.push_back(employee);
    return identifier;
}

auto insert(database &db, const schema::product &product) {
    auto identifier = id<table::products> { db.products.size() };
    db.products.push_back(product);
    return identifier;
}

void populate(database &db) {
    using namespace schema;
    
    auto kowalski_id = insert(db, employee { "Jan Kowalski", 2001 });
    auto sosna_id    = insert(db, employee { "Adam Sosna", 2012 });
    
    auto milk_id    = insert(db, product { "mleko", 2.f });
    auto sausage_id = insert(db, product { "kielbasa", 9.f });
    auto coal_id    = insert(db, product { "wungiel", 600.f });
    
    db.transactions.push_back(transaction {
        kowalski_id, milk_id, quantity(6)
    });
    
    db.transactions.push_back(transaction {
        kowalski_id, coal_id, quantity(10)
    });
    
    db.transactions.push_back(transaction {
        sosna_id, sausage_id, quantity(20)
    });
}

currency sum_transactions_of_employee(database &db, id<table::employees> employee_id) {
    currency sum = 0.f;
    for_each_if(
        std::begin(db.transactions),
        std::end(db.transactions),
        [employee_id](auto const &transaction) {
            return transaction.employee_id == employee_id;
        },
        [&sum, &db](auto const &transaction) {
            auto const &product = db.products[transaction.product_id.value];
            sum += product.price * transaction.quantity;
        }
    );
    return sum;
}


int main() {
    using namespace table;
    using namespace schema;
    database db;
    populate(db);
    
    for(auto id = 0u; id < db.employees.size(); ++id) {
        std::cout << sum_transactions_of_employee(db, { id }) << std::endl;
    }
    
    return 0;
}

6012
180

laczna_wartosc = cena_prod * ts1[i].daj_ilosc_sprzedanych(); 

laczna_wartosc1 += laczna_wartosc; 

laczna_wartosc += cena_prod * ts1[i].daj_ilosc_sprzedanych();