https://abload.de/thumb/cpul67.jpg

Punkt 1 und 2 glaube ich habe ich soweit gelöst. Nur bei der dritten Funktion bin ich verloren, alles versucht, verkrampft und mich endgültig geschlagen gegeben.
Hier der Code.

#include <iostream>
#include <string>

using namespace std;

int squareMe(int var1, int var2,unsigned int &erg1,unsigned int &erg2);
float halfMe(float var11, float *p_var11, float var22, float *p_var22);

double  negateMe();

int main()

{
	int var1;
	int var2;
	unsigned int erg1;
	unsigned int erg2;

	cout << "Funktion squareMe, geben sie jeweils zwei Paramter ein" << endl;
	cin >> var1;
	cin >> var2;
	squareMe(var1, var2, erg1, erg2);
	cout << var1 << "\n" << var2 << endl;
	cout << erg1 << "\n"  << erg2 << endl;

	float var11;
	float p_var11;
	float var22;
	float p_var22;

	cout << "Funktion halfMe, geben sie jeweils zwei Paramter ein" << endl;
	cin >> var11;
	cin >> var22;
	halfMe(var11, &p_var11, var22, &p_var22);
	cout << p_var11 << endl;
	cout << p_var22 << endl;

	cout << "Funktion halfMe, geben sie jeweils zwei Paramter ein" << endl;

	system("pause");
	return 0;
}

int squareMe(int var1, int var2, unsigned int &erg1,unsigned int &erg2)
{

	erg1 = var1 * var1;
	erg2 = var2 * var2;

	return 0;
} 

float halfMe(float var11, float *p_var11, float var22, float *p_var22)
{
	*p_var11 = var11 / 2;
	*p_var22 = var22 / 2;
	return 0;
}

double  negateMe()
{

	return 0;
}

Wie zum Teufel soll ich die Funktion mit zwei Referenzen laut Aufgabenstellung zusammen wurschteln?

std::pair<int,int> squareMe(int a, int b)                                                                               
{                                                                                                                       
    return { a * a, b * b };  // Vielleicht etwas einfacher: return std::make_pair(a * a, b * b);                                                                                
}                                                                                                                       

int halfMe(float *a, float *b)                                                                                          
{                                                                                                                       
    *a /= 2.0;  // Aequivalent: *a = *a / 2.0                                                                                           
    *b /= 2.0;                                                                                                          
    return 0;                                                                                                           
}                                                                                                                       

int negateMe(double &a, double &b)                                                                                      
{                                                                                                                       
    a = -a;                                                                                                             
    b = -b;                                                                                                             
    return 0;                                                                                                           
}                                                                                                                       

int main()                                                                                                              
{                                                                                                                       
    cout << "Aufgabe 1\n";                                                                                              
    int a = 2;                                                                                                          
    int b = 3;                                                                                                          
    auto p = squareMe(2, 3);                                                                                            
    cout << "a = " << a << '\n';                                                                                        
    cout << "b = " << b << '\n';                                                                                        
    cout << "a * a = " << p.first << '\n';                                                                              
    cout << "b * b = " << p.second << '\n';                                                                             

    cout << "\nAufgabe 2\n";                                                                                            
    float x = 8.4;                                                                                                      
    float y = 4.4;                                                                                                      
    halfMe(&x, &y);                                                                                                     
    cout << "x = " << x << '\n';                                                                                        
    cout << "y = " << y << '\n';                                                                                        

    cout << "\nAufgabe 3\n";                                                                                            
    double u = 3.4;                                                                                                     
    double v = 8.3;                                                                                                     
    negateMe(u, v);                                                                                                     
    cout << "u = " << u << '\n';                                                                                        
    cout << "v = " << v << '\n';                                                                                        
}

Falls dir der Code unklar ist, dann frag einfach nach

Aber auch negativ: ich verstehe die Funktionssignaturen nicht!

Warum soll squareMe 2 Parameter nehmen und nicht einen? Strenggenommen wiederholt man ja den Berechnungscode für beide Parameter sogar, wenn man beide quadriert. Es ergibt für mich wenig Sinn, hier beide Werte zu quadrieren und dann beide zurückzugeben.

Dieselbe Frage stelle ich mir auch für halfMe und negateMe. Warum haben die nicht nur einen Parameter? Und dann diese idiotischen Rückgabetypen. Wenn eine Funktion eh immer 0 returnen soll, warum dann nicht gleich gar nichts (void) als Rückgabetyp wählen?

Super gemacht, jetzt ist er schon durchgefallen.

hast Recht. icarus2 hat die Aufgabenstellung nicht genau genug gelesen.

In der Aufgabenstelleung heißt es doch ganz klar: ".. zwei Parameter, diese sind Pointer .." und ".. werden beide Parameter in ihrem Wert halbiert"
Die richtige Lösung für Aufgabe 2 ist:

// die zweite Funktion heißt 'halfMe'
// sie besitzt zwei Parameter, diese sind Pointer vom Typ float
//      -> es gibt keine Pointer vom Typ float; gemeint ist sicher ".. vom Typ Pointer auf float"
// die Funktion gibt immer den Wert 0 zurück;
//      -> damit liegt die Signatur fest:
int halfMe(float* param1, float* param2);
// In der Funktion werden beide Parameter in ihrem Wert halbiert
//      -> mehr steht da nicht, also ist die Implementierung auch klar
int halfMe(float* param1, float* param2)
{
    // .. beim Halbieren von Pointern muss Gewalt angewendet werden:
    static_assert(sizeof(void*) == sizeof(std::uint32_t), "int size muss gleich Pointer size sein");
    reinterpret_cast<std::uint32_t&>(param1) /=2;
    reinterpret_cast<std::uint32_t&>(param2) /=2;
    return 0;
}

// die Funktion wird in der main-Funktion aufgerufen und die veränderten Werte ausgegeben:
#include <iostream>

int main()
{
    using namespace std;
    float a=56.1f;
    float b=0.f;
    halfMe(&a, &b);
    // ..  und die veränderten Werte ausgegeben (!?)
    auto param1=&a;
    auto param2=&b;
    cout << reinterpret_cast<std::uint32_t>(param1 )/2 << " " << reinterpret_cast<std::uint32_t>(param2)/2 << endl;
    return 0;
}

Tipp: wechsele die Schule.

blablabla...

Wayne?

Zur Aufgabenstellung ansich: ich finde es positiv, dass globale Variablen verboten sind und die Funktionen selbst kein cout enthalten sollen.

sonst kann man sich ja auch wunderbar um die verwendung von zeigern und referenzen herumdrücken.

Warum soll squareMe 2 Parameter nehmen und nicht einen?

Dieselbe Frage stelle ich mir auch für halfMe und negateMe. Warum haben die nicht nur einen Parameter? Und dann diese idiotischen Rückgabetypen. Wenn eine Funktion eh immer 0 returnen soll, warum dann nicht gleich gar nichts (void) als Rückgabetyp wählen?

das sind theoretische aufgaben, mit denen abgefragt werden soll, ob man das prinzip verstanden hat.

ps: ich würde als rückgabetyp für aufgabe 1 ein long long int verwenden und die beiden werte dann einfach da reinschieben.