Попросил дать Hello World на C++, дало:

#include <iostream>

int main()
{
    std::cout << "Hello, World!" << std::endl;
    return 0;
}

Спросил что можно улучшить в коде, еще раз спросил и т.д. Повторил несколько раз. В итоге получил:

#include <iostream>
#include <string_view>

namespace
{
    // _lit1 is the first (and only) string literal
    constexpr std::string_view _lit1{ "Hello, World!" };
}

// Prints the given message
[[nodiscard]] inline bool printGreeting674321(std::string_view message)
{
    std::cout << message << '\n';
    return std::cout.good();
}

int main()
{
    std::ios::sync_with_stdio(false);

    if (!printGreeting674321(_lit1))
        return 1;
}

Стало ли лучше?

Здравствуйте, Shmj, Вы писали:

S>Стало ли лучше?
Адназначна. Для меня загдка только цифра 67432. Загуглил — почтовый код какого-то города в Канзасе

Здравствуйте, bnk, Вы писали:

S>>Стало ли лучше?
bnk>Адназначна. Для меня загдка только цифра 67432. Загуглил — почтовый код какого-то города в Канзасе

И в чем же стало лучше?

Т.е. в том то и фишка — он не понимает предназначения кода — а в отрыве от реального мира — все теряет смысл.

Здравствуйте, Shmj, Вы писали:

S>Здравствуйте, bnk, Вы писали:

S>>>Стало ли лучше?
bnk>>Адназначна. Для меня загдка только цифра 67432. Загуглил — почтовый код какого-то города в Канзасе

S>И в чем же стало лучше?

S>Т.е. в том то и фишка — он не понимает предназначения кода — а в отрыве от реального мира — все теряет смысл.

Ну так про это и пословица есть — заставь дурака богу молиться
Это не делает его бесполезным. IMHO сейчас вполне себе полезный ассистент.
Когда он сможет догадываться о твоих потаенных желаниях и смыслах, я надеюсь что буду уже на пенсии.

#include <iostream>
#include <string_view>
#include <format>
#include <memory>
#include <concepts>
#include <thread>
#include <vector>
#include <algorithm>
#include <exception>

// Concept constraining to printable string-like types
template <typename T>
concept Printable = requires(T a) {
    { std::format("{}", a) } -> std::convertible_to<std::string>;
};

// Compile-time Hello world message
consteval std::string_view getMessage() noexcept {
    return "Hello, World!";
}

// Interface for output targets, for DI and testability
struct IPrinter {
    virtual ~IPrinter() = default;
    virtual void print(std::string_view message) const noexcept = 0;
};

// Console printer implementation
struct ConsolePrinter : IPrinter {
    void print(std::string_view message) const noexcept override {
        try {
            // Use std::format for advanced formatting
            std::cout << std::format("[Console] {}\n", message);
        } catch (...) {
            // Fallback on error
            std::cout << message << '\n';
        }
    }
};

// A mock printer to demonstrate polymorphic substitution (e.g. for testing)
struct MockPrinter : IPrinter {
    mutable std::vector<std::string> messages;
    void print(std::string_view message) const noexcept override {
        messages.push_back(std::string(message));
    }
};

// Generic function templated on Printable concept
template<Printable T>
void printMessage(const IPrinter& printer, const T& message) noexcept {
    printer.print(std::format("[Message] {}", message));
}

// Thread worker that prints a series of messages safely
void threadWorker(const IPrinter& printer, std::vector<std::string_view> messages) noexcept {
    for (auto&& msg : messages) {
        printMessage(printer, msg);
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
    }
}

int main() {
    constexpr auto hello = getMessage();

    // Dependency injected printer
    auto printer = std::make_unique<ConsolePrinter>();

    // Print initial hello message
    printMessage(*printer, hello);

    // Spawn multiple threads printing variations of hello
    std::vector<std::string_view> variants = {
        "Hello, World!",
        "Bonjour, le Monde!",
        "Hola, Mundo!",
        "Hallo, Welt!",
        "Ciao, Mondo!"
    };

    // Runs threads that print messages concurrently
    std::vector<std::jthread> threads;
    for (int i = 0; i < 3; ++i) {
        threads.emplace_back(threadWorker, std::cref(*printer), variants);
    }

    // Join happens automatically when jthread destructs

    return 0;
}

S>>>Стало ли лучше?
bnk>>Адназначна. Для меня загдка только цифра 67432. Загуглил — почтовый код какого-то города в Канзасе
S>И в чем же стало лучше?

В критериях оценки, естественно.
Даже не ожидал что у тебя такой тупой вопрос возникнет.

Здравствуйте, bnk, Вы писали:

S>>Стало ли лучше?
bnk>Адназначна. Для меня загдка только цифра 67432. Загуглил — почтовый код какого-то города в Канзасе

Там 674321, а не 67432
Посёлок Молодёжный возле Приаргунска, Забайкальский край.

Я правильно понял, это там на самом деле установлена так называемая Массачусетская Машина?

S>int main()
S>{
S> std::ios::sync_with_stdio(false);

S> if (!printGreeting674321(_lit1))
S> return 1;
S>}
S>[/ccode]

S>Стало ли лучше?
UB стало, нет return-а у main-а

Здравствуйте, ononim, Вы писали:

O>UB стало, нет return-а у main-а

Разве?

A return statement ([stmt.return]) in main has the effect of leaving the main function (destroying any objects with automatic storage duration and evaluating any postcondition assertions of main) and calling std​::​exit with the return value as the argument. If control flows off the end of the compound-statement of main, the effect is equivalent to a return with operand 0 (see also [except.handle]).

Здравствуйте, Shmj, Вы писали:

S>Спросил что можно улучшить в коде, еще раз спросил и т.д. Повторил несколько раз. В итоге получил:

он плохо улучшил, слабо читаемо, вот нормальный вариант от deepseek, куда более лаконичный и понятный:

#include <iostream>
#include <type_traits>
#include <utility>
#include <memory>
#include <stdexcept>
#include <string>
#include <cstdlib>

// ==================== Macros ====================
#define DEFINE_EXCEPTION(name) \
    class name : public std::runtime_error { \
    public: \
        explicit name(const std::string& msg) : std::runtime_error(msg) {} \
    }

#define DECLARE_SINGLETON(cls) \
    public: \
        static cls& instance() { \
            static cls inst; \
            return inst; \
        } \
        cls(const cls&) = delete; \
        cls& operator=(const cls&) = delete; \
    private: \
        cls() {} \

#define TEMPLATE_TYPEDEF(alias, T) \
    template<typename... Args> \
    using alias = T<Args...>

// ==================== Exceptions ====================
namespace Exceptions {
    DEFINE_EXCEPTION(HelloWorldError);
    DEFINE_EXCEPTION(CharacterGenerationError);
    DEFINE_EXCEPTION(MessageCompositionError);
}

// ==================== Policies ====================
namespace Policies {
    template<typename T>
    struct CharacterGenerationPolicy {
        static_assert(std::is_same<T, char>::value, "Must generate chars");
        virtual T generate() = 0;
        virtual ~CharacterGenerationPolicy() = default;
    };
}

// ==================== Template Metaprogramming ====================
namespace Meta {
    template<int N>
    struct Factorial {
        static constexpr int value = N * Factorial<N - 1>::value;
    };

    template<>
    struct Factorial<0> {
        static constexpr int value = 1;
    };

    template<typename... Ts>
    struct TypeList {};

    template<typename T, typename U>
    struct IsSame : std::false_type {};

    template<typename T>
    struct IsSame<T, T> : std::true_type {};
}

// ==================== Logger ====================
class Logger {
    DECLARE_SINGLETON(Logger);
public:
    template<typename T>
    void log(const T& msg) {
        std::cout << "[LOG] " << msg << std::endl;
    }
};

// ==================== Character Generator ====================
template<typename Policy>
class CharacterGenerator : public Policy {
    static_assert(
        std::is_base_of<Policies::CharacterGenerationPolicy<char>, Policy>::value,
        "Policy must inherit from CharacterGenerationPolicy<char>"
    );
public:
    explicit CharacterGenerator(Policy&& policy) : Policy(std::move(policy)) {}

    char get_next() {
        try {
            return this->generate();
        } catch (...) {
            throw Exceptions::CharacterGenerationError("Failed to generate character");
        }
    }
};

// ==================== Message Composer ====================
template<typename Generator>
class MessageComposer {
public:
    explicit MessageComposer(Generator gen) : gen_(std::move(gen)) {}

    std::string compose() {
        try {
            std::string msg;
            msg += gen_.get_next(); // H
            msg += gen_.get_next(); // e
            msg += gen_.get_next(); // l
            msg += gen_.get_next(); // l
            msg += gen_.get_next(); // o
            msg += gen_.get_next(); // ,
            msg += gen_.get_next(); //  
            msg += gen_.get_next(); // W
            msg += gen_.get_next(); // o
            msg += gen_.get_next(); // r
            msg += gen_.get_next(); // l
            msg += gen_.get_next(); // d
            msg += gen_.get_next(); // !
            return msg;
        } catch (...) {
            throw Exceptions::MessageCompositionError("Failed to compose message");
        }
    }

private:
    Generator gen_;
};

// ==================== Concrete Policies ====================
class SequentialCharacterPolicy : public Policies::CharacterGenerationPolicy<char> {
public:
    explicit SequentialCharacterPolicy(const std::string& chars) 
        : chars_(chars), pos_(0) {}

    char generate() override {
        if (pos_ >= chars_.size()) {
            throw Exceptions::CharacterGenerationError("No more characters");
        }
        return chars_[pos_++];
    }

private:
    std::string chars_;
    size_t pos_;
};

// ==================== Factory ====================
namespace Factory {
    template<typename Policy>
    auto create_generator(Policy&& policy) {
        return CharacterGenerator<std::decay_t<Policy>>(std::forward<Policy>(policy));
    }

    template<typename Generator>
    auto create_composer(Generator&& gen) {
        return MessageComposer<std::decay_t<Generator>>(std::forward<Generator>(gen));
    }
}

// ==================== Utility Functions ====================
template<typename T>
constexpr auto type_name() {
    return __PRETTY_FUNCTION__;
}

template<typename... Ts>
void unused(Ts&&...) {}

// ==================== Main Program ====================
int main() {
    try {
        // Initialize logger
        Logger::instance().log("Starting Hello World program");

        // Compile-time factorial check
        static_assert(Meta::Factorial<5>::value == 120, "Factorial failed");

        // Create generator and composer
        auto generator = Factory::create_generator(
            SequentialCharacterPolicy("Hello, World!")
        );
        auto composer = Factory::create_composer(std::move(generator));

        // Compose and print message
        std::cout << composer.compose() << std::endl;

        // Type system demonstration
        unused(type_name<decltype(composer)>());

    } catch (const Exceptions::HelloWorldError& e) {
        Logger::instance().log(std::string("Error: ") + e.what());
        return EXIT_FAILURE;
    }

    return EXIT_SUCCESS;
}

Здравствуйте, bnk, Вы писали:

bnk>Адназначна. Для меня загдка только цифра 67432.

Вот тоже первая мысль, что было бы прикольно у него попросить обосновать свой выбор числа

O>>UB стало, нет return-а у main-а
S>

A return statement ([stmt.return]) in main has the effect of leaving the main function (destroying any objects with automatic storage duration and evaluating any postcondition assertions of main) and calling std​::​exit with the return value as the argument. If control flows off the end of the compound-statement of main, the effect is equivalent to a return with operand 0 (see also [except.handle]).

То есть для return-а это не UB, а только для остальных функци. Г — лоГика.

bnk>>Адназначна. Для меня загдка только цифра 67432.
G>Вот тоже первая мысль, что было бы прикольно у него попросить обосновать свой выбор числа
Возможно это самое случайное число в мире, просто чтобы минимизировать риск clash-а имени функции.

Здравствуйте, ononim, Вы писали:

O>>>UB стало, нет return-а у main-а
S>>

A return statement ([stmt.return]) in main has the effect of leaving the main function (destroying any objects with automatic storage duration and evaluating any postcondition assertions of main) and calling std​::​exit with the return value as the argument. If control flows off the end of the compound-statement of main, the effect is equivalent to a return with operand 0 (see also [except.handle]).

O>То есть для return-а это не UB, а только для остальных функци. Г — лоГика.

А main вообще своеобразная функция.
Может быть и `int main()`, и `int main(int, char **)`. Причем по поводу этой логики претензии, вроде как, нужно к чистой Си-шечке применять.

S>А main вообще своеобразная функция.
S>Может быть и `int main()`, и `int main(int, char **)`. Причем по поводу этой логики претензии, вроде как, нужно к чистой Си-шечке применять.
Ну с аргументами это как раз таки не проблема, компилятору нет то них дела, это проблемы линкера (которых у сишечного линкера как раз и нету).
А вот то что компилятор по особенному смотрит на отсутствие return у main — это забавно

Здравствуйте, ononim, Вы писали:


O>Ну с аргументами это как раз таки не проблема, компилятору нет то них дела, это проблемы линкера (которых у сишечного линкера как раз и нету).
O>А вот то что компилятор по особенному смотрит на отсутствие return у main — это забавно

Прикол в том, что компилятор ругается, когда пытаюсь один аргумент скормить.
А вот частичный ретурн у мэйна проглатывает, хотя у других выдает ворнинг.

test.cpp:7:5: warning: ‘int main(int)’ takes only zero or two arguments [-Wmain]
    7 | int main(int argc)
      |     ^~~~
test.cpp: In function ‘int f(int)’:
test.cpp:4:1: warning: control reaches end of non-void function [-Wreturn-type]
    4 | }

Здравствуйте, RonWilson, Вы писали:

RW>он плохо улучшил, слабо читаемо, вот нормальный вариант от deepseek, куда более лаконичный и понятный:

Ну вы сколько итераций "по улучшению" выполнили? Возможно после 50 итераций и GPT такое выдаст.

Здравствуйте, ononim, Вы писали:

O>UB стало, нет return-а у main-а

В main return не обязателен

Здравствуйте, Shmj, Вы писали:

S>Стало ли лучше?

Ты у нас спрашиваешь?

O>>UB стало, нет return-а у main-а
M>В main return не обязателен
спасибо, мне уже сообщили

Здравствуйте, ononim, Вы писали:

O>>>UB стало, нет return-а у main-а
M>>В main return не обязателен
O>спасибо, мне уже сообщили

Не мог пройти мимо