# Problem Implementierung

• Hallo alle zusammen ,bin mir nicht sicher ob ich hier beim letzten Teil der Aufgabe g) die Methode richtig implementiert habe ?
Bitte um Hilfe.
Es handelt sich um eine Alte Klausur wo ich keine Lösung habe leider .

``````#ifndef CCOMPONENT_H_
#define CCOMPONENT_H_
#include<iostream>
#include<string>
#include<cmath>

enum unit_t{MICRO,MILLI,ONE,KILO,MEGA};
class CComponent{
private:
std::string m_name;
std::string m_type;
double m_value;
unit_t m_unit;

public:
CComponent(std::string name ="NoName", std::string type ="Unbekanntes Bauteil",double value = 1,unit_t unit = ONE);
std::string getType();
int getUnitValue() const;
bool operator< ( CComponent const& rop );
friend std::ostream& operator<< (std::ostream& out,CComponent const& rop);

};
std::ostream& operator<< (std::ostream& out,CComponent const& rop);
``````
``````
#include<iostream>
#include"CComponent.h"
using namespace std;

CComponent::CComponent(string name, string type, double value, unit_t unit)
{
m_name = name;
if (type == "Widerstand" || type == "Kondensator" || type == "Spule"
|| type == "Unbekanntes Bauteil")
{
m_type = type;
}
else
{
m_type = "Unbekanntes Bauteil";
}

if (value > 0)
{
m_value = value;
}
else
{
m_value = 1;
}

m_unit = unit;
}

std::string CComponent::getType(){

return m_type;
}

int CComponent::getUnitValue() const{

switch (m_unit)
{
case MICRO:
return -6;
break;
case MILLI:
return -3;
break;
case ONE:
return 0;
break;
case KILO:
return 3;
break;
case MEGA:
return 6;
break;
default:
break;
}
cout << "ERROR: falsche Einheit" << endl;
return 0;
}

std::ostream& operator<< (std::ostream& out,CComponent const& rop){

out << rop.m_type << "" << rop.m_name  << ":" << rop.m_value <<"x" <<rop.getUnitValue() << endl;

return out;
}

bool CComponent::operator <(const CComponent& rop)
{

if (m_type == rop.m_type
&& pow(m_value, m_unit)
< pow(rop.m_value, rop.m_unit))
{

return true;
}
else
{
cout << "INFO: Bauelemente haben unterschiedlichen Typ";
return false;
}
}

``````
``````#ifndef CBOM_H_
#define CBOM_H_
#include<iostream>
#include "CComponent.h"
#include<string>

class CBom{
private:
CComponent* m_pComponents;
unsigned int m_size;
unsigned int m_nextFreePos = 0;

public:
CBom( unsigned int size = 0);
~CBom();
void  print();
unsigned int countComponents( std::string type);
CComponent getSmallestComponent(std::string type);

};

#endif /* CBOM_H_ */

``````

cpp

``````
#include<iostream>
#include"CBom.h"
using namespace std;

CBom::CBom( unsigned int size ){

if(size >10){

m_size = size;
}
else{
m_size =10;
}
m_nextFreePos = 0;
m_pComponents = new CComponent [m_size];

cout << "Adresse des Objekts: " << this << endl;
cout << "Adresse des ersten Elements: " << &m_pComponents[0] << endl;
cout << "Adresse des letzten Elements: " << &m_pComponents[m_size] << endl;

}

CBom::~CBom()
{
delete[] m_pComponents;
}

{
if (m_nextFreePos < m_size)
{
m_pComponents[m_nextFreePos++] = element;
return true;
}
return false;
}

void CBom::print()
{

cout << "Bill of Material " << endl;
cout << "=================" << endl;

for (unsigned int i = 0; i < m_nextFreePos; ++i)
{
cout << "Bauelement " << i << " : " << m_pComponents[i] << endl;
}

cout << "Anzahl Widerst‰nde: " << countComponents("Widerstand") << endl;
cout << "Anzahl Kondensatoren: " << countComponents("Kondensator") << endl;
}

unsigned int CBom::countComponents( std::string type){
int counter = 0;

for( unsigned int i  = 0; i<m_nextFreePos; i++){

if(type == m_pComponents[i].getType()){
counter++;

}

}
return counter;

}

CComponent CBom::getSmallestComponent(std::string type){
for( unsigned int i = &m_pComponents[0] ; i< m_nextFreePos; i++)
if( type < m_pComponents[i].getType()){

return  m_pComponents[i].getType();

}
else{
cout << "kein Element vom gewünschten Typ gefunden" << endl;

}

}

``````

Ist die Methode getsmallestComponent so gemeint?

• Nein, so wohl nicht. Du vergleichst bisher nur den Typ-Namen lexikographisch. Du sollst aber wohl anhand des `value` (und dessen `unit`) den kleinsten Wert [aus allen Bauteilen mit dem übergebenen Typ] ermitteln (wie ich aber sehe, hat deine Klasse `CComponent' bisher keine öffentlichen Getter dafür!?).

• Genau daher war ich mir unsicher ?
Soll ich eine getValue Methode erstellen ?
Und das dann etwa so in if einbauen ?

if(type.getValue() == m_pComponents[i].getValue())

• Das kompiliert so natürlich noch nicht einmal (`type` ist ein `std::string`).

In SQL würde die Abfrage etwa so aussehen:

``````SELECT MIN(value) FROM Components WHERE Components.Type == type
``````

Die Abfrage ist also zweistufig:

1. nur Komponenten desselben Typs vergleichen
2. minimalen Wert ermitteln

• ``````
CComponent CBom::getSmallestComponent(std::string type){
for( unsigned int i = &m_pComponents[0] ; i< m_nextFreePos; i++){
if( type == m_pComponents[i].getType()){

return  m_pComponents[i].getType();

}
else

{

cout << "kein Element vom gewünschten Typ gefunden" << endl;

}

}
}
``````

Wie soll ich das genau mit dem minimalen Wert machen ?
Verstehe es nicht

• ``````

CComponent CBom::getSmallestComponent(std::string type){

CComponent* min = new CComponent[m_size];
CComponent min1 = min[0];

for(  unsigned int i = 0; i<m_size; i++){
if( type == (m_pComponents[i].getType() )min < m_pComponents.getValue()){

return  m_pComponents[i].getType();

}
else

{

cout << "kein Element vom gewünschten Typ gefunden" << endl;

}

}
}
``````

Wäre das eine Möglichkeit den min Wert raus zu suchen?

• Was tüdelst du denn ja jetzt mit "new" rum?

Wie findet man denn das Minimum unter einer Bedingung in einer Menge an Elementen?

1. Finde das erste Element in der Menge, das die Bedingung erfüllt.
1a) Wenn keines gefunden wird, bist du fertig, gib einen nicht-gefunden-Fehlerwert zurück
2. Nimm dieses Element als dein vorläufiges Minimum an
3. Laufe durch den Rest der Menge.
3a) Wenn Element nicht die Bedingung erfüllt, überspringe es
3b) Ansonsten vergleiche den Wert mit dem vorläufigen Minimum. Wenn neuer Wert kleiner, übernimm diesen als vorläufiges Minimum
4. Dein vorläufiges Minimum ist nun dein Minimum.

Ist das so schwer?