Sumowanie ilości obiektów za pomocą operatora +=

W funkcji main tworzę listę dynamiczną jednokierunkową typu mojej klasy. Umieszczam w liście kilka obiektów za pomocą konstruktora.

Następnie muszę wykonać sumowanie obiektów za pomocą operatora +=, nie wiem jak to wykonać.
Jak wywołać ten operator w liście dynamicznej? Dodatkowo wyniki mają być zapisywanie do pomocniczych, lokalnych obiektów w funkcji main.

#include <iostream>
#include <cstdio>
using namespace std;

class kot {
      int i;
public:
    kot(): i(1) {};
    kot& operator+=(const kot& mk) {
                i += mk.i;
                return *this;
				cout << "\n#E: " << i;
    };
    //int get_i() { return i; };
	kot *next;
};
      
int main()
{
	kot *head = NULL, *wsk = NULL;
	
	for (int x=0; x < 3; x++){
		if(head == NULL){
			head = wsk = new kot;
			wsk->next = NULL;
		}
		else{
			wsk->next = new kot;
			wsk = wsk->next;
			wsk->next = NULL;
		}
	}	
	return 0;
};

Może ktoś powiedzieć, czy to rozwiązanie jest poprawne?
Liczba elementów się zgadza. :)

#include <iostream>
#include <cstdio>
using namespace std;

class kot {
      int i;
public:
    kot(): i(1) {};
	kot(int ii): i(ii){};
    kot& operator+=(const kot& mk) {
                i += mk.i;
                return *this;
				cout << "\n#E: " << i;
    };
    int get_i() { return i; };
	kot *next;
};
      
int main()
{
	kot *head = NULL, *wsk = NULL;
	
	for (int x=0; x < 3; x++){
		if(head == NULL){
			head = wsk = new kot;
			wsk->next = NULL;
		}
		else{
			wsk->next = new kot;
			wsk = wsk->next;
			wsk->next = NULL;
		}
	}	
	wsk = head;
	kot ala, alla(0);	
	while(wsk){
		wsk = wsk->next;
		alla += ala;
		cout << "Elementow: " << alla.get_i() << endl;		
	}
	return 0;
};

#include <iostream>
#include <memory>

class kot
{
public:
	kot(int x) : nr_(x) {}

	int numerKota() const { return nr_; }

private:
	int nr_;
};

class Node
{
public:
	Node(kot const& data): data_(data), next_(nullptr) {}

private:
	Node* next_;

	kot data_;
};

class MyList
{
public:
	MyList() : size_(0), head_(nullptr) {}

	void insert(kot const& kt) {

	}

	int const size() const { return size_; }
private:
	int size_;

	Node* head_;
};

od czegoś takiego bym wyszedł

kot powinien być templatem czyli dowolnym typem, który trzymany jest w nodzie

zbyt rozbudowane.
a co takiego u mnie jest źle?
wg mnie spełnia warunki z polecenia.

@btanreb żeby było ładnie powinieneś to podzielić. Klasa kot powinna reprezentować kota. Co obchodzi kota, który kot jest następny po nim w liście? Tym powinien zajmować się mechanizm listy. jeżeli by Ci to pomogło to;
http://ideone.com/yL4GeP

#include <iostream>
#include <string>
#include <sstream>
#include <ostream>

class Kot {
private:
	std::string gatunek;
	int wielkosc;
public:
	Kot(std::string gatunek,int wielkosc) :
		gatunek(gatunek), wielkosc(wielkosc) {}
	Kot() : gatunek(""), wielkosc(0) {}
	Kot& operator+=(const Kot& k) {
		wielkosc += k.wielkosc;
		gatunek += (gatunek.empty() ? k.gatunek : " "+k.gatunek);
		return *this;
	}
	friend std::ostream& operator<<(std::ostream& out,Kot &k) {
		std::stringstream w;
		w << k.wielkosc;
		out << k.gatunek+" "+w.str();
		return out;
	}
};

class ListaKotow {
private:
	typedef struct Element {
		Element *nastepny;
		Kot kot;
	} Element;
	Element *pierwszy;
	Element *ostatni;
public:
	ListaKotow() : pierwszy(NULL), ostatni(NULL) {}
	void push_back(Kot k) {
		Element *e = new Element;
		e->kot = k;
		e->nastepny = NULL;
		if(!pierwszy && !ostatni)
			pierwszy = e;
		else
			ostatni->nastepny = e;
		ostatni = e;
	}
	~ListaKotow() {
		Element *ns, *s = pierwszy;
		while(s) {
			ns = s->nastepny;
			delete s;
			s = ns;
		}
	}
	Kot dajSuperKotaMieszanca() {
		Kot superKotMieszaniec;
		Element *e;
		for(e = pierwszy; e; e=e->nastepny)
			superKotMieszaniec += e->kot;
		return superKotMieszaniec;
	}
};

int main(void) {
	ListaKotow koty;
	koty.push_back(Kot("Perski",12));
	koty.push_back(Kot("Brytyjski",10));
	koty.push_back(Kot("Egzotyczny",8));
	koty.push_back(Kot("Ragdoll",10));
	koty.push_back(Kot("Norweski",22));
	Kot mieszaniec = koty.dajSuperKotaMieszanca();
	std::cout << mieszaniec << std::endl;
	return 0;
}

@btanreb Pomijając fakt że stworzyłeś potwora kotowęzła który nie ma racji bytu jak w rzeczywistości tak i w programowaniu, ostatnią pętle w main, o tą:

    wsk = head;
    kot ala, alla(0);    
    while(wsk){
        wsk = wsk->next;
        alla += ala;
        cout << "Elementow: " << alla.get_i() << endl;        
    }

możesz śmiało zastąpić na:

int count=0;
for(wsk=head;wsk;wsk=wsk->next) cout<<"Elementow: "<<(++count)<<endl;

i dokładnie na to samo wyjdzie, a przy okazji nie potrzebujesz tego i w klasie, nie potrzebujesz operator+ itp

Stwórz klasę, w której będzie operator+= w formie metody należącej do klasy i w formie funkcji globalnej.
W funkcji main stwórz listę dynamiczną jednokierunkową. Dodaj kilka elementów za pomocą konstruktora domyślnego.
Następnie zlicz obiekty z listy dynamicznej za pomocą operatora +=, zapisując wynik do obiektów pomocniczych odpowiedniego typu zadeklarowanych jako obiekty lokalne funkcji main.

W zadaniu nie powiedziane że obiekty pomocnicze muszą być dokładnie takiego typu jak te dodane do listy.
Więc stwórz sobie klasę LicznikKotow w której będzie LicznikKotow &operator+=(const Kot &k) { ++Licznik; }
Sama lista może być taka jak podała @karolinaa lub jak podał @gośćabc.

Może źle to napisałem, ale "...zapisując wynik do obiektów pomocniczych odpowiedniego typu zadeklarowanych jako obiekty lokalne funkcji main."

No wszystko się zgadza:

int main()
  {
   ListaKotow koty;
   koty+=Kot("Perski",12);
   koty+=Kot("Brytyjski",10);
   koty+=Kot(); // tu domyślny jak w zadaniu
   LicznikKotow L;
   for(Kot *k=koty.first();k;k=k->next()) L+=*k;
   cout<<L.count()<<endl;
   return 0;
  }

Czy coś się nie zgadza z zadaniem?

funkcja main na pewno jest zła.
od paru ćwiczeń robimy od początku do końca listy dynamiczne w funkcji main bez dodatkowych klas.