Profémon C++ Tutorial: OOP-Klassen und Enumerationen für Csci135

Einführung in die Profémon-Welt: C++-Klassen und Enumerationen

Stell dir vor, du entwickelst dein eigenes Spiel – ähnlich wie Pokémon, aber mit einem Fokus auf Programmierung und Hardware. Genau das ist die Idee hinter dem Profémon-Projekt aus dem Kurs Csci135. In diesem Tutorial lernst du, wie du die beiden Klassen Skill und Profemon mit Header- und Source-Dateien in C++ implementierst. Dabei nutzen wir aktuelle Trends: Denk an die Beliebtheit von KI-Assistenten wie ChatGPT oder die Spannung der FIFA-Weltmeisterschaft 2026 – genauso wie ein Profémon verschiedene Spezialisierungen hat (ML, SOFTWARE, HARDWARE), besitzt jeder Skill einzigartige Eigenschaften.

Warum OOP und Enumerationen? Vom Spiel zur realen Anwendung

Objektorientierte Programmierung (OOP) ist das Rückgrat moderner Softwareentwicklung – von Apps wie Instagram bis zu Finanzsystemen. In diesem Projekt lernst du, wie du mit Klassen und Enumerationen klare Strukturen schaffst. Ein Profémon ist wie ein Charakter in einem Spiel: Es hat einen Namen, Level, Spezialität und bis zu drei Skills. Die Enumeration Specialty (ML, SOFTWARE, HARDWARE) definiert, in welchem Bereich das Profémon besonders stark ist – ähnlich wie ein Fußballspieler eine Position hat (Stürmer, Verteidiger, Torwart).

Die Skill-Klasse: Grundbaustein der Profémon-Fähigkeiten

Bevor wir das Profémon selbst bauen, brauchen wir die Skill-Klasse. Ein Skill repräsentiert eine Aktion oder Fähigkeit, die ein Profémon einsetzen kann. Jeder Skill hat einen Namen, eine Beschreibung und einen Wirkungswert (z. B. Schaden oder Heilung).

Header-Datei: skill.hpp

Definiere die Klasse mit privaten Membervariablen und öffentlichen Methoden. Verwende std::string für Namen und Beschreibung, int für den Wert.

// skill.hpp
#ifndef SKILL_HPP
#define SKILL_HPP

#include <string>

class Skill {
private:
    std::string name;
    std::string description;
    int value;

public:
    Skill();
    Skill(std::string name, std::string description, int value);
    std::string getName() const;
    std::string getDescription() const;
    int getValue() const;
    void setName(std::string name);
    void setDescription(std::string description);
    void setValue(int value);
};

#endif

Source-Datei: skill.cpp

Implementiere die Methoden. Besonders wichtig: Standardkonstruktor und parametrisierter Konstruktor.

// skill.cpp
#include "skill.hpp"

Skill::Skill() : name(""), description(""), value(0) {}

Skill::Skill(std::string name, std::string description, int value)
    : name(name), description(description), value(value) {}

std::string Skill::getName() const { return name; }
std::string Skill::getDescription() const { return description; }
int Skill::getValue() const { return value; }

void Skill::setName(std::string name) { this->name = name; }
void Skill::setDescription(std::string description) { this->description = description; }
void Skill::setValue(int value) { this->value = value; }

Die Profemon-Klasse: Das Herzstück mit Enumeration

Die Profemon-Klasse ist komplexer. Sie enthält eine Enumeration Specialty (außerhalb der Klasse definiert) und private Member für Name, Level, Spezialität und ein Array von maximal drei Skills.

Enumeration Specialty

Definiere die Enumeration vor der Klasse in der Header-Datei. Die Reihenfolge ist wichtig: ML, SOFTWARE, HARDWARE.

// In profemon.hpp vor der Klasse
enum Specialty { ML, SOFTWARE, HARDWARE };

Header-Datei: profemon.hpp

Die Klasse hat private Member: std::string name, int level, Specialty specialty, und ein Array von Skill-Objekten (z. B. Skill skills[3]) sowie einen Zähler int skillCount.

// profemon.hpp
#ifndef PROFEMON_HPP
#define PROFEMON_HPP

#include <string>
#include "skill.hpp"

enum Specialty { ML, SOFTWARE, HARDWARE };

class Profemon {
private:
    std::string name;
    int level;
    Specialty specialty;
    Skill skills[3];
    int skillCount;

public:
    Profemon();
    Profemon(std::string name, int level, Specialty specialty);
    std::string getName() const;
    int getLevel() const;
    Specialty getSpecialty() const;
    Skill* getSkills();
    int getSkillCount() const;
    void setName(std::string name);
    void setLevel(int level);
    void setSpecialty(Specialty specialty);
    bool addSkill(Skill skill);
    void printInfo() const;
};

#endif

Source-Datei: profemon.cpp

Implementiere die Methoden. Der Konstruktor initialisiert das Array und den Zähler. Die Methode addSkill fügt einen Skill hinzu, wenn noch Platz ist.

// profemon.cpp
#include "profemon.hpp"
#include <iostream>

Profemon::Profemon() : name(""), level(0), specialty(ML), skillCount(0) {}

Profemon::Profemon(std::string name, int level, Specialty specialty)
    : name(name), level(level), specialty(specialty), skillCount(0) {}

std::string Profemon::getName() const { return name; }
int Profemon::getLevel() const { return level; }
Specialty Profemon::getSpecialty() const { return specialty; }
Skill* Profemon::getSkills() { return skills; }
int Profemon::getSkillCount() const { return skillCount; }

void Profemon::setName(std::string name) { this->name = name; }
void Profemon::setLevel(int level) { this->level = level; }
void Profemon::setSpecialty(Specialty specialty) { this->specialty = specialty; }

bool Profemon::addSkill(Skill skill) {
    if (skillCount < 3) {
        skills[skillCount] = skill;
        skillCount++;
        return true;
    }
    return false;
}

void Profemon::printInfo() const {
    std::cout << "Name: " << name << std::endl;
    std::cout << "Level: " << level << std::endl;
    std::cout << "Specialty: ";
    switch (specialty) {
        case ML: std::cout << "ML"; break;
        case SOFTWARE: std::cout << "SOFTWARE"; break;
        case HARDWARE: std::cout << "HARDWARE"; break;
    }
    std::cout << std::endl;
    std::cout << "Skills: " << std::endl;
    for (int i = 0; i < skillCount; i++) {
        std::cout << "- " << skills[i].getName() << ": " << skills[i].getDescription() << " (Wert: " << skills[i].getValue() << ")" << std::endl;
    }
}

Zusammenspiel der Klassen: Beispiel aus der Praxis

Stell dir vor, du erstellst ein Profémon namens „CodeBot“ mit der Spezialität SOFTWARE und Level 5. Du gibst ihm drei Skills: „Bug Fix“ (Wert 10), „Refactor“ (Wert 20) und „Deploy“ (Wert 30). In der main-Funktion würdest du das testen:

#include <iostream>
#include "profemon.hpp"

int main() {
    Profemon p("CodeBot", 5, SOFTWARE);
    p.addSkill(Skill("Bug Fix", "Repariert einen Fehler", 10));
    p.addSkill(Skill("Refactor", "Verbessert Code-Struktur", 20));
    p.addSkill(Skill("Deploy", "Stellt die Anwendung bereit", 30));
    p.printInfo();
    return 0;
}

Dieses Beispiel zeigt, wie du mit OOP und Enumerationen modularen Code schreibst. Ähnlich wie bei der Fußball-WM 2026, wo jedes Team spezifische Strategien hat, hat jedes Profémon seine eigene Spezialität und Skills.

Tipps zur Fehlervermeidung und Kompilierung

Um deine Dateien zu kompilieren, nutze folgenden Befehl im Terminal:

g++ -std=c++11 -Wall skill.cpp profemon.cpp main.cpp -o profemon

Achte darauf, dass du alle .cpp-Dateien angibst. Häufige Fehler sind fehlende Include-Guards oder vergessene Semikolons. Teste jede Funktion einzeln, um sicherzustellen, dass Getter und Setter korrekt arbeiten.

Trends und Analogien: Warum Profemon mehr als ein Spiel ist

Die Idee hinter Profemon ist nicht nur ein Spiel – sie spiegelt reale Softwareentwicklung wider. In Zeiten von KI-Tools wie ChatGPT (ML-Spezialität) oder der Entwicklung von Apps für die Fußball-EM 2028 (SOFTWARE) lernst du hier grundlegende Konzepte, die in jedem Tech-Job gefragt sind. Die Enumeration hilft, Typen sicher zu definieren, ähnlich wie Fußballpositionen oder Kategorien in einer Datenbank.

Zusammenfassung und nächste Schritte

In diesem Tutorial hast du gelernt, wie man die Klassen Skill und Profemon in C++ mit Header- und Source-Dateien erstellt, inklusive einer Enumeration für Spezialitäten. Experimentiere mit eigenen Profémon und Skills – vielleicht ein KI-gestütztes Profémon mit ML-Spezialität? Viel Erfolg bei deinem Csci135-Projekt!