Entwickler, die stark auf KI zur Generierung von C++-Code setzen, sollten vorsichtig sein

KI-gestützte Codegenerierung gewinnt in der Softwareentwicklung zunehmend an Bedeutung. Fortschrittliche Modelle werden eingesetzt, um Code zu schreiben, zu optimieren und zu verstehen. KI soll Entwickler jedoch nicht ersetzen, sondern sie bei ihrer Arbeit unterstützen. Letztlich entscheiden Menschen, wie sie die Vorschläge der KI nutzen. Betrachten wir dazu diese Anfrage, die wir GPT-4o gestellt haben:

Gib mir eine C++-Funktion, die zwei große Ganzzahlen addiert

Hier ist die Antwort:

Um zwei große Ganzzahlen in C++ zu addieren, können Sie den Datentyp string verwenden, um beliebig große Zahlen zu verarbeiten. Hier ist eine Funktion, die zwei als Strings dargestellte große Ganzzahlen addiert:

#include <iostream>
#include <string>
#include <algorithm>

// Function to add two big integers
std::string addBigIntegers(const std::string& num1, const std::string& num2) {
    std::string result = "";
    int carry = 0;

    // Make sure num1 is the longer string
    std::string n1 = num1.size() >= num2.size() ? num1 : num2;
    std::string n2 = num1.size() < num2.size() ? num1 : num2;

    // Reverse the strings to make addition easier
    std::reverse(n1.begin(), n1.end());
    std::reverse(n2.begin(), n2.end());

    // Add digit by digit
    for (size_t i = 0; i < n1.size(); ++i) {
        int digit1 = n1[i] - '0';
        int digit2 = i < n2.size() ? n2[i] - '0' : 0;
        int sum = digit1 + digit2 + carry;
        carry = sum / 10;
        result.push_back((sum % 10) + '0');
    }

    // If there is a carry left, add it
    if (carry) {
        result.push_back(carry + '0');
    }

    // Reverse the result to get the final sum
    std::reverse(result.begin(), result.end());

    return result;
}

int main() {
    std::string num1, num2;

    // Prompt the user for the first big integer
    std::cout << "Enter the first big integer: ";
    std::cin >> num1;

    // Prompt the user for the second big integer
    std::cout << "Enter the second big integer: ";
    std::cin >> num2;

    // Call the addBigIntegers function and store the result
    std::string sum = addBigIntegers(num1, num2);

    // Output the result
    std::cout << "The sum of " << num1 << " and " << num2 << " is " << sum << "." << std::endl;

    return 0;
}

Das Problem bei dieser Antwort liegt in der Interpretation der Anfrage. In diesem Fall liefert GPT eine Lösung für extrem große Zahlen, ähnlich wie viele online verfügbare Lösungen für solche Fälle. Was aber, wenn der Entwickler unter einer „großen Zahl“ lediglich Werte bis zu einer Milliarde versteht?

In diesem Szenario erhalten wir wegen des unzureichend definierten Kontexts eine überdimensionierte Lösung, die den Code unnötig verkomplizieren kann. Der Kontext spielt bei der Codegenerierung mit KI eine entscheidende Rolle. Deshalb ist es wichtig, Anforderungen präzise zu formulieren, statt nur allgemeine Anweisungen zu geben.

Sehen wir uns ein weiteres Beispiel an, das die Bedeutung des Kontexts verdeutlicht.

Gib mir C++-Code, um Objekte in einer Datei zu speichern und daraus zu laden

Die Antwort lautet:

#include <iostream>
#include <fstream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    // Constructor
    Person() : name(""), age(0) {}
    Person(const std::string& n, int a) : name(n), age(a) {}

    // Method to display the person's information
    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }

    // Friend functions for serialization and deserialization
    friend std::ofstream& operator<<(std::ofstream& ofs, const Person& p);
    friend std::ifstream& operator>>(std::ifstream& ifs, Person& p);
};

// Overload the << operator for writing a Person object to a file
std::ofstream& operator<<(std::ofstream& ofs, const Person& p) {
    ofs << p.name << std::endl;
    ofs << p.age << std::endl;
    return ofs;
}

// Overload the >> operator for reading a Person object from a file
std::ifstream& operator>>(std::ifstream& ifs, Person& p) {
    std::getline(ifs, p.name);
    ifs >> p.age;
    ifs.ignore();  // Ignore the newline character after reading age
    return ifs;
}

Und die main-Funktion:

int main() {
    // Create a Person object
    Person p1("John Doe", 30);

    // Save the object to a file
    std::ofstream ofs("person.txt");
    if (ofs.is_open()) {
        ofs << p1;
        ofs.close();
        std::cout << "Person saved to file." << std::endl;
    } else {
        std::cerr << "Error opening file for writing." << std::endl;
    }

    // Retrieve the object from the file
    Person p2;
    std::ifstream ifs("person.txt");
    if (ifs.is_open()) {
        ifs >> p2;
        ifs.close();
        std::cout << "Person read from file:" << std::endl;
        p2.display();
    } else {
        std::cerr << "Error opening file for reading." << std::endl;
    }

    return 0;
}

Hier stoßen wir auf ein weiteres Problem: Der Code erfindet das Rad neu, um die Aufgabe zu erledigen. Das führt zu mehr Codezeilen und damit zu höherer Komplexität.

Wenn wir dieselbe Anfrage jedoch um zusätzliche Vorgaben ergänzen:

Gib mir C++-Code, um Objekte mithilfe der bekanntesten dafür geeigneten Bibliotheken in einer Datei zu speichern und daraus zu laden

In diesem Fall verwendet die Antwort die Boost-Bibliothek:

#include <iostream>
#include <fstream>
#include <vector>
#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>

Zusammenfassend gilt: Unterschätzen Sie bei der Generierung von C++-Code mit KI niemals die Bedeutung des Kontexts. Er ist entscheidend, um relevante Antworten zu erhalten. Formulieren Sie Ihre Anfrage daher besonders sorgfältig – darin liegt der Schlüssel zu guten Ergebnissen!