Banalne pytanie na temat wydajności

[Orb]

Nie robię jeszcze na tyle zaawansowanych programów, żeby robiło to dla mnie różnicę, ale jak ja się uczę czegokolwiek, to wole robić wszystko perfekcyjnie. Proste dwie funkcje jedna wprowadza liczby a druga dzieli. Który sposób na wprowadzenie danych teoretycznie będzie wydajniejszy?

Sposób I:

#include <iostream>

using std::cin;

void WprowadzInt( int & a )
{
	cin >> a;
}
void Dzielenie()
{
	int dzielna, dzielnik;
	WprowadzInt( dzielna );
	WprowadzInt( dzielnik );
	Podziel( dzielna, dzielnik );
}

SposóbII:

#include <iostream>

using std::cin;

int WprowadzInt()
{
	int a;
	cin >> a;
	return a;
}
void Dzielenie()
{
	int dzielna = WprowadzInt();
	int dzielnik = WprowadzInt();
	Podziel( dzielna, dzielnik );
}

Ja obstawiam, że sposobem I, bo przez referencje dzielna i dzielnik są definiowane tylko raz, jednak chciałbym aby to ocenił ktoś kto zna się lepiej ode mnie.

[Orb]

Wygląda na to, że poprzednie pytanie było za głupie, żeby ktoś odpowiedział. Teraz więc dręczy mnie inna rozkmina. Uczę się przeładowywać operatory na podstawie kursu z wiki: C++/Przeciążanie operatorów - Wikibooks, biblioteka wolnych podręczników

Pierwszy przykład niby zrozumiałem. Wykonałem coś podobnego tylko w inny sposób. Skompilowało się i działało. W drugim (rzekomo prostszym) przykładzie coś mi nie gra. Siedzę nad przykładem przeładowania:

class Student
 {
    //...
    public:
       int operator==(const Student &q) {return nr_indeksu==q.nr_indeksu;}
       int operator==(const int &q) {return nr_indeksu==q;}
 };

Pierwsza funkcja jeśli dobrze rozumiem ma za zadanie umożliwić porównanie dwóch instancji klasy student pod względem indeksu. Pierwsze, co przyszło mi na myśl to czy nie da się porównać bez przeciążania. Oczywiście zakładałem, że jeśli zadziała, to będzie sprawdzało czy obiekty są identycznie. Kompilator stwierdził, że "==" nie wie co operator ma robić z obiektem tej klasy. Nie zdziwiłem się, bo niby po co autor kursu miałby podawać przykład, który prościej jest zrobić bez prezentowanego narzędzia. Mimo to zawsze sprawdzam kiedy się czegoś uczę, czy aby na pewno to potrzebne. Dlatego mniej więcej kumając pierwszą funkcje przeładowania napisałem szybki kod wykorzystujący go w prosty sposób:

#include <iostream>
#include <string>

using namespace std;

class Student
{
	int nr_indeksu;
	float srednia_ocen;
	public:
		Student( int nr = 0, float sr = 0 ):
		nr_indeksu( nr ),
		srednia_ocen( sr )
		{
		}
	friend ostream &operator<<( ostream &wyjscie, const Student &s )
	{
		return wyjscie << "Nr Indeksu: " << s.nr_indeksu << endl << "Średnia Ocen: " << s.srednia_ocen << endl;
	}
	int operator==( const Student &q ) { return nr_indeksu==q.nr_indeksu; }
};

int main()
{
	Student pawel( 1, 5 ), pawelek( 1, 5 );
	if( pawel == pawelek )
		cout << pawel;
	else
		cout << "pawel != pawelek" << endl;
	return 0;
}

Kompiluje się i działa, wygląda na to że łapie. Tylko dalej nie wiem po co w przykładzie to drugie przeładowanie. Myślę, myślę i dochodzę do wniosku, że skoro w niej argumentem jest int, to ma umożliwić porównanie nr indeksu do zmiennej int. Jeśli tak, to przy użyciu tylko pierwszego przeładowania nie powinno się dać tego wykonać ( inaczej by nie miało sensu robienie oddzielnej funkcji porównującej indeks z int ). Sprawdzam więc:

#include <iostream>
#include <string>

using namespace std;

class Student
{
	int nr_indeksu;
	float srednia_ocen;
	public:
		Student( int nr = 0, float sr = 0 ):
		nr_indeksu( nr ),
		srednia_ocen( sr )
		{
		}
	friend ostream &operator<<( ostream &wyjscie, const Student &s )
	{
		return wyjscie << "Nr Indeksu: " << s.nr_indeksu << endl << "Średnia Ocen: " << s.srednia_ocen << endl;
	}
	int operator==( const Student &q ) { return nr_indeksu==q.nr_indeksu; }
};

int main()
{
	Student pawel( 1, 5 );
	if( pawel == 1 )
		cout << pawel;
	else
		cout << "pawel != 1" << endl;
	return 0;
}

Ku mojemu zdziwieniu kod kompiluje a odpalony wyświetla indeks i średnią pawła. Czyli jednak drugie przeładowanie dla "==" albo ma inne zastosowanie, albo jest tu nie potrzebne. Myślę jednak, że autor nie podawałby przykładu zawierający zbędną funkcje. Więc głowię się nie mogąc zasnąć i nie mam pomysłu po co te:

int operator==(const int &q) {return nr_indeksu==q;}

Będę wdzięczny zarówno za odpowiedź na dręczące mnie pytanie, jak i za wytknięcie błędów w moim toku rozumowania, które umożliwią mi samodzielne rozwikłanie zagadki ( bardziej liczę na to drugie, po to tak się rozpisałem opisując główne przemyślenia ).