To developers who heavily rely on AI for generating C++ code. Be careful.

AI-driven code generation has become an increasingly important aspect of software development, leveraging advanced models to write, optimize, and understand code. However, AI is not intended to replace developers but rather to aid them in their tasks. Ultimately, it is up to humans to determine how to utilize AI suggestions. Let’s consider this query we posed to GPT-4o:

give me a c++ functon to add 2 big integers

Here’s the answer:

To add two big integers in C++, you can use the string data type to handle arbitrarily large numbers. Here is a function that adds two big integers represented as strings:

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

The issue with this response lies in the interpretation of the query. In this instance, GPT provides a solution suitable for handling extremely large numbers, which aligns with numerous online resources offering solutions for such cases. However, what if the developer’s definition of “big number” encompasses figures only up to one billion?

In this scenario, we encounter an over-engineered solution that might unnecessarily complicate the code due to the lack of well-defined context. Context plays a significant role when generating code from AI, emphasizing the importance of precisely specifying requirements rather than offering general instructions.

Let’s explore another example to underscore the significance of context.

give me a c++ code to store and get objects from a file

The answer is:

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

class Person {
    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 << << 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) {
    ifs >> p.age;
    ifs.ignore();  // Ignore the newline character after reading age
    return ifs;

And the main function:

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;
        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;
        std::cout << "Person read from file:" << std::endl;
    } else {
        std::cerr << "Error opening file for reading." << std::endl;

    return 0;

In this instance, we encounter another issue where the code reinvents the wheel to accomplish the task, resulting in more lines of code and consequently, increased complexity.

However, if we pose the same query with additional specifications:

give me a c++ code to store and get objects from a file by using most know libraries capable to do it

The answer in this case use the boost lib:

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

To summarize, when generating C++ code using AI, never underestimate the importance of context. It’s the key to receiving relevant answers. Therefore, pay close attention to your query—it’s the secret sauce!