如何在C++编译时检测const char*格式错误？

问：

我正在尝试编写一个函数“my_func（）”，该函数在编译时计算字符串中的字符数“a”，这使得当“a”的计数错误时代码无法编译。

我受到 C++ 标准库中函数的启发，该函数检查格式字符串中的数字。std::format(){}

我使用的编译器是msvc，C++20。

我下面的代码无法编译，因为我不知道如何实现这样的功能。那么我该如何修复功能呢？my_func()

template <size_t Size>
auto my_func(const char(&str)[Size]) -> void {
    // dosomething...

    constexpr size_t count = 0;
    const char* c = str;
    for (size_t i = 0; i < Size; ++i) {
        if (*c == 'a') {
            count++; // const values cannot be modified
        }
        c++;
    }

    // If the variable `count ` is not set to constexpr, an error will be reported here.
    static_assert(count == 2);

    // dosomething...
}

auto main() -> int {
    my_func("abc abc"); // is error
}

下一个

感谢@ecatmur的回答，但是当 str 转换为 .counting_string

我尝试将构造函数的模板参数传递给类，但这阻止了我在调用函数时找到匹配的重载函数。prepare

template <char Char, size_t Count, size_t Size>
struct counting_string {
    std::array<char, Size> m_chars;

    // NOLINTNEXTLINE(google-explicit-constructor)
    consteval explicit(false) counting_string(char const (&str)[Size]) {
        size_t count = 0;
        const char* c = str;
        for (size_t i = 0; i < Size; ++i) {
            if (*c == Char) {
                count++;
            }
            c++;
        }
        if (count != Count) {
            throw "invalid str";
        }
    }
};

template <size_t Size, class... Args>
auto prepare(const counting_string<'?', sizeof...(Args), Size> sql, Args... args) -> void {
// use sql as: sql.m_chars.data();
}

auto main() -> int {
    // call function error
    // prepare("insert into test (name, age) values (?, ?)", 1, 2);
}

下面的代码是我希望实现的最终结果。 在没有额外开销（编译时检查）的情况下，检查 SQL 语句中的占位符数量以避免错误。

template <char Char, size_t Count>
struct constexpr_counting_string {
    template <size_t Size>
    // NOLINTNEXTLINE(google-explicit-constructor)
    consteval explicit(false) constexpr_counting_string(char const (&str)[Size]) {
        size_t count = 0;
        const char* c = str;
        for (size_t i = 0; i < Size; ++i) {
            if (*c == Char) {
                count++;
            }
            c++;
        }
        if (count != Count) {
            throw "invalid str";
        }
    }
};

// prepare and bind
template <typename... Args>
auto prepare(statement_t& stmt, constexpr_counting_string<'?', sizeof...(Args)> sql, Args... args) noexcept -> code_t {
    // prepare
    code_t error = helper_prepare(stmt, sql);

    // bind
    auto do_bind = [](statement_t& stmt, size_t n, auto arg, code_t& error) noexcept {
        if (error != code_t::ok) {
            return;
        }

        using arg_type = decltype(arg);

        if constexpr (std::is_same_v<arg_type, uint64_t>) {
            error = stmt.bind(n, arg);
        }
        else if constexpr (std::is_same_v<arg_type, int64_t>) {
            error = stmt.bind(n, arg);
        }
        else if constexpr (std::is_same_v<arg_type, int>) {
            error = stmt.bind(n, arg);
        }
        else if constexpr (std::is_same_v<arg_type, const char*>) {
            error = stmt.bind(n, arg);
        }
        else {
            static_assert(std::is_same_v<arg_type, uint64_t>, "args error");
        }
    };

    size_t index = 0;
    (do_bind(stmt, index++, args, error), ...);
    return error;
}

auto main() -> int {
    prepare("insert into test (name, age) values (?, ?)", 1, 2);
}