Декларирование строки фиксированного размера

Question

В C мы

char buffer[100]; 

Есть ли способ, чтобы объявить фиксированный размер std::string?

Answer 1

Я не знаю, что вы хотите сделать, но с std::array<char, 100> buffer; вы должны преуспеть.

Вы можете получить строку, как это:

std::string str(std::begin(buffer),std::end(buffer); 

Answer 2

Вы можете использовать string::reserve метод как этот

std::string s; 
    s.reserve(100); 

Но это не фиксированный размер, потому что вы можете добавить больше символов в строка с строкой :: push_back, например.

Answer 3

В C++ 17 будет std::string_view, который предлагает тот же (неизменный) интерфейс, что и std::string.

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

template<std::size_t N> 
struct immutable_string 
{ 
    using ref = const char (&)[N+1]; 
    constexpr immutable_string(ref s) 
    : s(s) 
    {} 

    constexpr auto begin() const { return (const char*)s; } 
    constexpr auto end() const { return begin() + size(); } 
    constexpr std::size_t size() const { return N; } 
    constexpr ref c_str() const { return s; } 
    ref s; 

    friend std::ostream& operator<<(std::ostream& os, immutable_string s) 
    { 
     return os.write(s.c_str(), s.size()); 
    } 
}; 

template<std::size_t NL, std::size_t NR> 
std::string operator+(immutable_string<NL> l, immutable_string<NR> r) 
{ 
    std::string result; 
    result.reserve(l.size() + r.size()); 
    result.assign(l.begin(), l.end()); 
    result.insert(result.end(), r.begin(), r.end()); 
    return result; 
} 

template<std::size_t N> 
auto make_immutable_string(const char (&s) [N]) 
{ 
    return immutable_string<N-1>(s); 
} 

int main() 
{ 
    auto x = make_immutable_string("hello, world"); 
    std::cout << x << std::endl; 

    auto a = make_immutable_string("foo"); 
    auto b = make_immutable_string("bar"); 
    auto c = a + b; 
    std::cout << c << std::endl; 
} 

Answer 4

Вы можете использовать std::array, который является метод C++ делать именно то, что вы делали в C .

std::array<char, 100> buffer; 

Если вы беспокоитесь о переполнении стека из-за больших размеров буфера (как, например, если 100 является дублером для 1'000'000) можно динамически выделять его вместо этого.

std::unique_ptr<std::array<char, 100>> buffer = std::make_unique<std::array<char, 100>>(); 

Поскольку ваш интерфейс принимает char * как операнд, и этот объект позволяет запросить его размер во время выполнения, это должно быть достаточно.