C++

Forum

 
Need help with my mock exam yet again

sapi3ntia (7)
I am sry to trouble u guy, but i am stuck again. Same rule I get a main.cpp and muss write classes to make it output the supposed output. I am not allowed to modify main.cpp (I am also not allowed to add includes and so on.).

I cant post the error message because its too long, but the first one is error: no matching function for call to »Smoothie::Smoothie(<brace-enclosed initializer list>)«

The output I am supposed to get are the commends after the return 0 in main.cpp.

I am 95% sure that the constructor from the Smoothie class is the culprit. It has two member first one is just the name string bezeichnung. The second member is a vector of objects(that class has a string member and an int member). The problem is that main.cpp sometimes initites the Smoothie class with only one parameter or less and i dont know how to (sometimes ignore it, and sometimes output an error massage).


main.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
#include<iostream>
#include<vector>
#include<string>
#include<stdexcept>
#include"Smoothie.h"
#include "Zutat.h"
using namespace std;

int main() {
    Zutat z1{"Apfel"};
    try {
        Zutat z1{""};
        cout  << "Error 1\n";
    }
    catch (runtime_error& e) {
        cout << "Leerer Name nich erlaubt!\n";
    }
    try {
        Zutat z2("Abfel", 200);
        cout << "Error 2\n";
    }
    catch (runtime_error& e) {
        cout << "Brennwert zu hoch!\n";
    }
    try {
        Zutat z2("Apfel", 0);
        cout << "Error 3\n";
    }
    catch (runtime_error& e) {
        cout << "Brennwert zu niedrig!\n";
    }
    cout << (z1 == Zutat{"Apfel",12}) << (Zutat{"Birne"}==z1) << (z1==Zutat{"Apfel",32}) << '\n';
    cout << z1.brennwert() << Zutat{"Birne",17}.brennwert() << '\n';
    cout << Zutat{"Birne",17} << z1 << '\n';
    try {
        Smoothie s{""};
        cout << "Error 3\n";
    }
    catch (runtime_error& e) {
        cout << "Smoothie muss eine Bezeichnung haben!\n";
    }
    Smoothie s{"Turm von Hanoi"};
    s.hinzu(Zutat{"Apfel"});
    s.hinzu(Zutat{"Birne",31});
    s.hinzu(Zutat{"Apfel",32});
    cout << s << ", " << s.brennwert() << '\n';
    cerr << s << '\n';

    //Dekommentieren fuer Zusatzbeispiel unterheben
    /*
    s.unterheben(Zutat{"Banane",40});
    cout << s <<'\n';
    try {
      Smoothie{"Test"}.unterheben(z1);
      cout << "Error 4\n";
    }
    catch (runtime_error& e) {
      cout << "Unterheben nicht moeglich!\n";
    }
    */

    //Dekommentieren fuer Zusatzbeispiel liste
    /*
    s.liste(cout);
    cout<<'\n';
    s.liste(cerr);
    cerr<<'\n';
    */

    return 0;
}

/*
Leerer Name nich erlaubt!
Brennwert zu hoch!
Brennwert zu niedrig!
001
3217
[Birne 17 kJ][Apfel 32 kJ]
Smoothie muss eine Bezeichnung haben!
[{[Apfel 32 kJ], [Birne 31 kJ], [Apfel 32 kJ]}, Turm von Hanoi], 95
[{[Apfel 32 kJ], [Birne 31 kJ], [Apfel 32 kJ]}, Turm von Hanoi]

//Ausgabe Zusatzbeispiel unterheben
[{[Banane 40 kJ], [Apfel 32 kJ], [Banane 40 kJ], [Birne 31 kJ], [Banane 40 kJ], [Apfel 32 kJ]}, Turm von Hanoi]
Unterheben nicht moeglich!

//Ausgabe Zusatzbeispiel liste
[Banane 40 kJ]*3, [Apfel 32 kJ]*2, [Birne 31 kJ]*1
[Banane 40 kJ]*3, [Apfel 32 kJ]*2, [Birne 31 kJ]*1

 */



Zutat.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
 
#include "Zutat.h"
#include<iostream>
#include<vector>
#include<string>
#include<stdexcept>
#include"smoothie.h"
using namespace std;

Zutat::Zutat(string name, int brennwert) {
    this->name=name;
    this->brennw=brennwert;

    if(name.size() == 0) {
        throw runtime_error("Leerer Name nich erlaubt!");
    }if(brennwert < 10){
        throw runtime_error("Brennwert zu niedrig!");
    }if(brennwert > 75){
        throw runtime_error("Brennwert zu hoch");
    }
}

int Zutat::brennwert() const {
    return brennw;
}

bool Zutat::operator==(const Zutat& z) const{
    return (name == z.name && brennw == z.brennw);
}

ostream& Zutat::print(ostream& o) const{
    o << "[" << name << " " << brennw << " kJ]";
    return o;
}

ostream& operator<< (ostream& o, const Zutat& z){
    z.print(o);
    return o;
}



Zutat.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
#ifndef CLION_ZUTAT_H
#define CLION_ZUTAT_H

#include<iostream>
#include<vector>
#include<string>
#include<stdexcept>
#include"smoothie.h"
using namespace std;

class Zutat {
private:
    string name;
    int brennw;
public:
    Zutat(string, int = 32);
    int brennwert() const;
    bool operator==(const Zutat&) const;
    ostream& print(ostream&) const;
};

ostream& operator<< (ostream&, const Zutat&);

#endif //CLION_ZUTAT_H



Smoothie.cpp

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include "Smoothie.h"
#include "Zutat.h"
using namespace std;

Smoothie::Smoothie(string bezeichnung, vector<Zutat> zutaten)
    :bezeichnung(bezeichnung),
     zutaten(zutaten)
{
//    this->bezeichnung = bezeichnung;

    if(bezeichnung.size() == 0){
        throw runtime_error("Smoothie muss eine Bezeichnung haben!");
    }

//    this->zutaten = zutaten;

}

void Smoothie::hinzu(const Zutat& z) {
    zutaten.push_back(z);
}

int Smoothie::brennwert() const {
    int sum =0;

    for(size_t i = 0; i < zutaten.size(); i++){
        sum += zutaten[i].brennwert();
    }

    return sum;
}

ostream& Smoothie::print(ostream& o) const{
    o << "[{";
    for(int i = 0; i < zutaten.size(); i++){
        o << zutaten[i] << ", ";
    }
    o << "}, " << bezeichnung << "}" << endl;
    return o;
}

ostream& operator<< (ostream& o, const Smoothie& s){
    s.print(o);
    return o;
}



Smoothie.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 
#ifndef CLION_SMOOTHIE_H
#define CLION_SMOOTHIE_H

#include<iostream>
#include<vector>
#include<string>
#include<stdexcept>
#include"Smoothie.h"
#include "Zutat.h"
using namespace std;

class Smoothie {
private:
    string bezeichnung;
    vector<Zutat> zutaten;
public:
    Smoothie(string, vector<Zutat>);
    void hinzu(const Zutat&);
    int brennwert() const;
    ostream& print(ostream&) const;
};

ostream& operator<< (ostream&, const Smoothie&);

#endif //CLION_SMOOTHIE_H
coder777 (8443)
The problem is that the constructor of Smoothie has a second parameter vector<Zutat>);. This is neither expected in main nor is it necessary. So simply remove the second parameter.
coder777 (8443)
The problem is indeed that the constructor of Smoothie has a second parameter vector<Zutat>. This is neither expected in main nor is it necessary. So simply remove the second parameter.
Enoizat (1343)
main.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
#include<iostream>
#include<vector>
#include<string>
#include<stdexcept>
#include"Smoothie.h"
#include "Zutat.h"
using namespace std;

int main() {
    Zutat z1{"Apfel"};
    try {
        Zutat z1{""};
        cout  << "Error 1\n";
    }
    catch (runtime_error& e) {
        cout << "Leerer Name nich erlaubt!\n";
    }
    try {
        Zutat z2("Abfel", 200);
        cout << "Error 2\n";
    }
    catch (runtime_error& e) {
        cout << "Brennwert zu hoch!\n";
    }
    try {
        Zutat z2("Apfel", 0);
        cout << "Error 3\n";
    }
    catch (runtime_error& e) {
        cout << "Brennwert zu niedrig!\n";
    }
    cout << (z1 == Zutat{"Apfel",12}) << (Zutat{"Birne"}==z1) << (z1==Zutat{"Apfel",32}) << '\n';
    cout << z1.brennwert() << Zutat{"Birne",17}.brennwert() << '\n';
    cout << Zutat{"Birne",17} << z1 << '\n';
    try {
        Smoothie s{""};
        cout << "Error 3\n";
    }
    catch (runtime_error& e) {
        cout << "Smoothie muss eine Bezeichnung haben!\n";
    }
    Smoothie s{"Turm von Hanoi"};
    s.hinzu(Zutat{"Apfel"});
    s.hinzu(Zutat{"Birne",31});
    s.hinzu(Zutat{"Apfel",32});
    cout << s << ", " << s.brennwert() << '\n';
    cerr << s << '\n';

    //Dekommentieren fuer Zusatzbeispiel unterheben
    /*
    s.unterheben(Zutat{"Banane",40});
    cout << s <<'\n';
    try {
      Smoothie{"Test"}.unterheben(z1);
      cout << "Error 4\n";
    }
    catch (runtime_error& e) {
      cout << "Unterheben nicht moeglich!\n";
    }
    */

    //Dekommentieren fuer Zusatzbeispiel liste
    /*
    s.liste(cout);
    cout<<'\n';
    s.liste(cerr);
    cerr<<'\n';
    */

    return 0;
}

/*
Leerer Name nich erlaubt!
Brennwert zu hoch!
Brennwert zu niedrig!
001
3217
[Birne 17 kJ][Apfel 32 kJ]
Smoothie muss eine Bezeichnung haben!
[{[Apfel 32 kJ], [Birne 31 kJ], [Apfel 32 kJ]}, Turm von Hanoi], 95
[{[Apfel 32 kJ], [Birne 31 kJ], [Apfel 32 kJ]}, Turm von Hanoi]

//Ausgabe Zusatzbeispiel unterheben
[{[Banane 40 kJ], [Apfel 32 kJ], [Banane 40 kJ], [Birne 31 kJ], [Banane 40 kJ], [Apfel 32 kJ]}, Turm von Hanoi]
Unterheben nicht moeglich!

//Ausgabe Zusatzbeispiel liste
[Banane 40 kJ]*3, [Apfel 32 kJ]*2, [Birne 31 kJ]*1
[Banane 40 kJ]*3, [Apfel 32 kJ]*2, [Birne 31 kJ]*1

 */


Zutat.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#ifndef CLION_ZUTAT_H
#define CLION_ZUTAT_H


#include <iostream>
#include <string>


class Zutat {
private:
    std::string name;
    int brennw;
public:
    Zutat(const std::string& name_arg, int brennw_arg = 32);
    int brennwert() const;
    bool operator==(const Zutat&) const;
    friend std::ostream& operator<<(std::ostream& o, const Zutat& z);
};



#endif //CLION_ZUTAT_H


Zutat.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
#include "Zutat.h"


Zutat::Zutat(const std::string& name_arg, int brennwert) {
    if(name_arg.size() == 0) {
        throw std::runtime_error("Leerer Name nich erlaubt!");
    } else {
        name = name_arg;
    }
    
    if(brennwert < 10) {
        throw std::runtime_error("Brennwert zu niedrig!");
    } else if(brennwert > 75) {
        throw std::runtime_error("Brennwert zu hoch");
    } else {
        brennw = brennwert;
    }
}

int Zutat::brennwert() const {
    return brennw;
}

bool Zutat::operator==(const Zutat& z) const{
    return (name == z.name && brennw == z.brennw);
}

std::ostream& operator<< (std::ostream& o, const Zutat& z){
    return (o << "[" << z.name << ": " << z.brennw << " kJ]");
}


Smoothie.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
#ifndef CLION_SMOOTHIE_H
#define CLION_SMOOTHIE_H


#include <iostream>
#include <string>
#include <vector>
#include "Smoothie.h"
#include "Zutat.h"


class Smoothie {
private:
    std::string bezeichnung;
    std::vector<Zutat> zutaten;
public:
    Smoothie(const std::string& bezeichnung_arg = "", 
             const std::vector<Zutat>& zutaten_arg = {});
    void hinzu(const Zutat& z);
    int brennwert() const;
    friend std::ostream& operator<< (std::ostream& o, const Smoothie& s);
};



#endif //CLION_SMOOTHIE_H


Smoothie.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include "Smoothie.h"
#include "Zutat.h"


Smoothie::Smoothie(const std::string& bezeichnung_arg, const std::vector<Zutat>& zutaten_arg)
    : bezeichnung(bezeichnung_arg), zutaten(zutaten_arg)
{
    // If you throw your exception here, the (expensive) initialization of
    // your vector by copy has already been performed.
    if(bezeichnung.size() == 0){
        throw std::runtime_error("Smoothie muss eine Bezeichnung haben!");
    }
}


void Smoothie::hinzu(const Zutat& z) {
    zutaten.push_back(z);
}


int Smoothie::brennwert() const {
    int sum = 0;

    for(size_t i = 0; i < zutaten.size(); i++){
        sum += zutaten[i].brennwert();
    }

    return sum;
}


std::ostream& operator<< (std::ostream& o, const Smoothie& s){
    o << "[{";
    for(size_t i = 0; i < s.zutaten.size(); i++){
        o << s.zutaten[i] << ", ";
    }
    o << "}, " << s.bezeichnung << "}\n";
    return o;
}


output:
Leerer Name nich erlaubt!
Brennwert zu hoch!
Brennwert zu niedrig!
001
3217
[Birne: 17 kJ][Apfel: 32 kJ]
Smoothie muss eine Bezeichnung haben!
[{[Apfel: 32 kJ], [Birne: 31 kJ], [Apfel: 32 kJ], }, Turm von Hanoi}
, 95
[{[Apfel: 32 kJ], [Birne: 31 kJ], [Apfel: 32 kJ], }, Turm von Hanoi}


P.s.
great nickname, sapi3ntia, congrats.
Enoizat (1343)
main.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
#include<iostream>
#include<vector>
#include<string>
#include<stdexcept>
#include"Smoothie.h"
#include "Zutat.h"
using namespace std;

int main() {
    Zutat z1{"Apfel"};
    try {
        Zutat z1{""};
        cout  << "Error 1\n";
    }
    catch (runtime_error& e) {
        cout << "Leerer Name nich erlaubt!\n";
    }
    try {
        Zutat z2("Abfel", 200);
        cout << "Error 2\n";
    }
    catch (runtime_error& e) {
        cout << "Brennwert zu hoch!\n";
    }
    try {
        Zutat z2("Apfel", 0);
        cout << "Error 3\n";
    }
    catch (runtime_error& e) {
        cout << "Brennwert zu niedrig!\n";
    }
    cout << (z1 == Zutat{"Apfel",12}) << (Zutat{"Birne"}==z1) << (z1==Zutat{"Apfel",32}) << '\n';
    cout << z1.brennwert() << Zutat{"Birne",17}.brennwert() << '\n';
    cout << Zutat{"Birne",17} << z1 << '\n';
    try {
        Smoothie s{""};
        cout << "Error 3\n";
    }
    catch (runtime_error& e) {
        cout << "Smoothie muss eine Bezeichnung haben!\n";
    }
    Smoothie s{"Turm von Hanoi"};
    s.hinzu(Zutat{"Apfel"});
    s.hinzu(Zutat{"Birne",31});
    s.hinzu(Zutat{"Apfel",32});
    cout << s << ", " << s.brennwert() << '\n';
    cerr << s << '\n';

    //Dekommentieren fuer Zusatzbeispiel unterheben
    /*
    s.unterheben(Zutat{"Banane",40});
    cout << s <<'\n';
    try {
      Smoothie{"Test"}.unterheben(z1);
      cout << "Error 4\n";
    }
    catch (runtime_error& e) {
      cout << "Unterheben nicht moeglich!\n";
    }
    */

    //Dekommentieren fuer Zusatzbeispiel liste
    /*
    s.liste(cout);
    cout<<'\n';
    s.liste(cerr);
    cerr<<'\n';
    */

    return 0;
}

/*
Leerer Name nich erlaubt!
Brennwert zu hoch!
Brennwert zu niedrig!
001
3217
[Birne 17 kJ][Apfel 32 kJ]
Smoothie muss eine Bezeichnung haben!
[{[Apfel 32 kJ], [Birne 31 kJ], [Apfel 32 kJ]}, Turm von Hanoi], 95
[{[Apfel 32 kJ], [Birne 31 kJ], [Apfel 32 kJ]}, Turm von Hanoi]

//Ausgabe Zusatzbeispiel unterheben
[{[Banane 40 kJ], [Apfel 32 kJ], [Banane 40 kJ], [Birne 31 kJ], [Banane 40 kJ], [Apfel 32 kJ]}, Turm von Hanoi]
Unterheben nicht moeglich!

//Ausgabe Zusatzbeispiel liste
[Banane 40 kJ]*3, [Apfel 32 kJ]*2, [Birne 31 kJ]*1
[Banane 40 kJ]*3, [Apfel 32 kJ]*2, [Birne 31 kJ]*1

 */


Zutat.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
#ifndef CLION_ZUTAT_H
#define CLION_ZUTAT_H


#include <iostream>
#include <string>


class Zutat {
private:
    std::string name;
    int brennw;
public:
    Zutat(const std::string& name_arg, int brennw_arg = 32);
    int brennwert() const;
    bool operator==(const Zutat&) const;
    friend std::ostream& operator<<(std::ostream& o, const Zutat& z);
};



#endif //CLION_ZUTAT_H


Zutat.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
#include <iostream>
#include <stdexcept>
#include <string>
#include <vector>
#include "Zutat.h"


Zutat::Zutat(const std::string& name_arg, int brennwert) {
    if(name_arg.size() == 0) {
        throw std::runtime_error("Leerer Name nich erlaubt!");
    } else {
        name = name_arg;
    }
    
    if(brennwert < 10) {
        throw std::runtime_error("Brennwert zu niedrig!");
    } else if(brennwert > 75) {
        throw std::runtime_error("Brennwert zu hoch");
    } else {
        brennw = brennwert;
    }
}

int Zutat::brennwert() const {
    return brennw;
}

bool Zutat::operator==(const Zutat& z) const{
    return (name == z.name && brennw == z.brennw);
}

std::ostream& operator<< (std::ostream& o, const Zutat& z){
    return (o << "[" << z.name << ": " << z.brennw << " kJ]");
}


Smoothie.h:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
#ifndef CLION_SMOOTHIE_H
#define CLION_SMOOTHIE_H


#include <iostream>
#include <string>
#include <vector>
#include "Smoothie.h"
#include "Zutat.h"


class Smoothie {
private:
    std::string bezeichnung;
    std::vector<Zutat> zutaten;
public:
    Smoothie(const std::string& bezeichnung_arg = "", 
             const std::vector<Zutat>& zutaten_arg = {});
    void hinzu(const Zutat& z);
    int brennwert() const;
    friend std::ostream& operator<< (std::ostream& o, const Smoothie& s);
};



#endif //CLION_SMOOTHIE_H


Smoothie.cpp:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
 
#include <iostream>
#include <vector>
#include <string>
#include <stdexcept>
#include "Smoothie.h"
#include "Zutat.h"


Smoothie::Smoothie(const std::string& bezeichnung_arg, const std::vector<Zutat>& zutaten_arg)
    : bezeichnung(bezeichnung_arg), zutaten(zutaten_arg)
{
    // If you throw your exception here, the (expensive) initialization of
    // your vector by copy has already been performed.
    if(bezeichnung.size() == 0){
        throw std::runtime_error("Smoothie muss eine Bezeichnung haben!");
    }
}


void Smoothie::hinzu(const Zutat& z) {
    zutaten.push_back(z);
}


int Smoothie::brennwert() const {
    int sum = 0;

    for(size_t i = 0; i < zutaten.size(); i++){
        sum += zutaten[i].brennwert();
    }

    return sum;
}


std::ostream& operator<< (std::ostream& o, const Smoothie& s){
    o << "[{";
    for(size_t i = 0; i < s.zutaten.size(); i++){
        o << s.zutaten[i] << ", ";
    }
    o << "}, " << s.bezeichnung << "}\n";
    return o;
}


output:
Leerer Name nich erlaubt!
Brennwert zu hoch!
Brennwert zu niedrig!
001
3217
[Birne: 17 kJ][Apfel: 32 kJ]
Smoothie muss eine Bezeichnung haben!
[{[Apfel: 32 kJ], [Birne: 31 kJ], [Apfel: 32 kJ], }, Turm von Hanoi}
, 95
[{[Apfel: 32 kJ], [Birne: 31 kJ], [Apfel: 32 kJ], }, Turm von Hanoi}


P.s.
great nickname, sapi3ntia, congrats.
sapi3ntia (7)
coder777 (6452)


I think it was necessary because 

1
2
3
 
    
cout << s << ", " << s.brennwert() << '\n';
cerr << s << '\n';


outputs all the ingredients (zutaten) needed for the smoothie and calculates the calories(brennwert).

So i had to connect these two classes somehow.


Enoizat (310)


Thank you so much for your help. From your code i got much better understanding of C++ now.
coder777 (8443)
It is not necessary because of this:
1
2
3
4
5
 
    Smoothie s{"Turm von Hanoi"}; // No second parameter necessary
    s.hinzu(Zutat{"Apfel"}); // This adds the ingredient
    s.hinzu(Zutat{"Birne",31});
    s.hinzu(Zutat{"Apfel",32});
    cout << s << ", " << s.brennwert() << '\n';
coder777 (8443)
I think it was necessary because
Nein, die Zutaten werden hinzu()gefügt:
1
2
3
4
5
 
    Smoothie s{"Turm von Hanoi"}; // Kein weiterer Parameter notwendig
    s.hinzu(Zutat{"Apfel"}); // Zutaten werden hier hinzugefügt.
    s.hinzu(Zutat{"Birne",31});
    s.hinzu(Zutat{"Apfel",32});
    cout << s << ", " << s.brennwert() << '\n';
sapi3ntia (7)
I think it was necessary because
Nein, die Zutaten werden hinzu()gefügt:

Smoothie s{"Turm von Hanoi"}; // Kein weiterer Parameter notwendig
s.hinzu(Zutat{"Apfel"}); // Zutaten werden hier hinzugefügt.
s.hinzu(Zutat{"Birne",31});
s.hinzu(Zutat{"Apfel",32});
cout << s << ", " << s.brennwert() << '\n';


Oh, ok... Well I did it because it was writen on the sheet. It told me that the class would have these two objects
Topic archived. No new replies allowed.