Aux développeurs qui s’appuient massivement sur l’IA pour générer du code C++ : soyez prudents

La génération de code par l'IA est devenue un aspect de plus en plus important du développement logiciel, en s'appuyant sur des modèles avancés capables d'écrire, d'optimiser et de comprendre le code. Toutefois, l'IA n'a pas vocation à remplacer les développeurs, mais plutôt à les assister dans leur travail. En fin de compte, c'est à l'humain qu'il revient de décider comment exploiter les suggestions de l'IA. Prenons cette requête que nous avons soumise à GPT-4o :

donne-moi une fonction c++ pour additionner 2 grands entiers

Voici la réponse :

Pour additionner deux grands entiers en C++, vous pouvez utiliser le type de données string afin de manipuler des nombres arbitrairement grands. Voici une fonction qui additionne deux grands entiers représentés sous forme de chaînes :

#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;
}

Le problème de cette réponse tient à la manière dont la requête est interprétée. Ici, GPT fournit une solution adaptée à la manipulation de nombres extrêmement grands, à l'image de nombreuses solutions disponibles en ligne pour ce genre de cas. Mais que se passe-t-il si, pour le développeur, un « grand nombre » se limite à des valeurs allant jusqu'à un milliard ?

Dans ce scénario, nous nous retrouvons avec une solution surdimensionnée qui risque de compliquer inutilement le code, faute d'un contexte bien défini. Le contexte joue un rôle déterminant lorsqu'on génère du code avec l'IA, d'où l'importance de spécifier précisément ses besoins plutôt que de formuler des instructions générales.

Prenons un autre exemple pour illustrer l'importance du contexte.

donne-moi un code c++ pour stocker et lire des objets depuis un fichier

Voici la réponse :

#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;
}

Et la fonction main :

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;
}

Ici, nous rencontrons un autre problème : le code réinvente la roue pour accomplir la tâche, ce qui se traduit par davantage de lignes de code et, par conséquent, une plus grande complexité.

En revanche, si nous posons la même requête avec des précisions supplémentaires :

donne-moi un code c++ pour stocker et lire des objets depuis un fichier en utilisant les bibliothèques les plus connues capables de le faire

Dans ce cas, la réponse s'appuie sur la bibliothèque Boost :

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

Pour résumer, lorsque vous générez du code C++ avec l'IA, ne sous-estimez jamais l'importance du contexte. C'est la clé pour obtenir des réponses pertinentes. Accordez donc une attention toute particulière à votre requête : c'est elle qui fait toute la différence !