Can I repeat a std::string_view without copying when printing indentation?

Question

I have a simple scene in C++ code. I want to get a long string containing some repeated std::string_view; is there a way to achieve this without copying the string?

#include <cstdio>
#include <string_view>

struct Logger {
    static inline constexpr std::string_view indent = "    ";
    static inline int level = 0;

    Logger() {
        level++;
    }

    // ...
    
    void log(const std::string &msg) {
        std::printf(/* repeat indent 'level' times */);
    }
};

No, you'll have to copy into a new string. If you know in advance the maximum number of indents you'll need you could prepare a constant with the maximum length — Alan Birtles, Jun 27 '23 at 09:04
You could make a constexpr function thate creates a std::array with different levels of indentation. — Pepijn Kramer, Jun 27 '23 at 09:10
@康桓瑋 `std::format` returns a `std::string`, so that is copying. — Jan Schultke, Jun 27 '23 at 09:25
@康桓瑋 The OP seems to just want indentation, I'd [play](https://godbolt.org/z/77KrvszjK) with the align specifier. — Bob__, Jun 27 '23 at 09:33
I would recommend to use ready library for logging. [spdlog](https://github.com/gabime/spdlog) is pretty cool and based on fmt. — Marek R, Jun 27 '23 at 09:50
@康桓瑋 I don't think you can print a `std::ranges::repeat_view` directly anyways; it would have to be put into a `std::string` as an intermediate step. You could however set a fill-character in the format string to print indentation. — Jan Schultke, Jun 27 '23 at 10:03
@JanSchultke [Formatting Ranges](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2022/p2286r8.html). — 康桓瑋, Jun 27 '23 at 10:08
@463035818_is_not_an_ai I have to send all the characters together to a function in my project, so a loop cannot resolve my question — Gtylcara, Jul 04 '23 at 03:38

Jan Schultke · Accepted Answer · 2023-06-27T10:00:04.080

C-Style Solution

std::printf allows you to dynamically specify the field width. For example:

#include <cstdio>

int main() {
    int indent_length = 4;
    int indent_depth = 3;

    // note: "" is passed as an argument for %s
    std::printf("%*shi!", indent_length * indent_depth, "");
}

This will output:

hi!

We can use this trick because indentation always consist of one character, so we don't really have to repeat a full std::string_view. Obviously, this wouldn't work if you wanted indentation that is a mixture of multiple characters, but that would be highly unusual.

Old-School C++ Solution

However, that is a very C-style solution, and you could just use a loop to avoid copying:

void log(std::string_view msg) {
    for (int i = 0; i < level; ++i) {
        std::cout << indent;
    }
    std::cout << msg;
}

However, if the indent is not a mixture of different characters, we can do a similar trick using std::cout as above to avoid this loop:

void log(std::string_view msg) {
    std::cout << std::setw(indent_length * level) << "" << msg;
}

If you absolutely insist on using std::printf, we can still do:

// if msg is always null-terminated
std::printf("%s", msg.data());

// otherwise
std::printf("%.*s", int(msg.length()), msg.data());

Your indent string can be printed exactly the same way.

@HolyBlackCat the purpose of the question is to `printf` indentation a variable amount of times. Since the indentation is always a single a single character, we don't really need to repeat a full `std::string_view`, but we can repeat a single character. — Jan Schultke, Jun 27 '23 at 09:41
there is `fmt` library and `spdlog` based on it. Since C++23 there is `std::print` motivated by `fmt::print`. `fmt::print("{:{}}", "", indent);` — Marek R, Jun 27 '23 at 09:46

score 0 · Answer 2 · answered Jun 27 '23 at 09:32

The Answer to you question is NO,

but std::views::repeat or std::ranges::repeat_view can help you write more concise and more readable code.

In alternative, if you know a priori the max indentation, you could initialize a std::array of string_view, where the dimension is the number of max indentation, where each string_view, have incremental repetion of the pattern.

score 0 · Answer 3 · answered Jun 27 '23 at 09:43

I would try do longest possible ident and then extract subview form it:

using namespace std::string_view_literals;

constexpr auto MaxIndentView = "                                            "sv;

constexpr std::string_view indentView(size_t n)
{
    if (n * 4 > MaxIndentView.size()) {
        throw std::invalid_argument{"Max indentation reached"};
    }
    return MaxIndentView.substr(0, n * 4);
}

But I think this is not what you actually need.

Can I repeat a std::string_view without copying when printing indentation?

3 Answers3

C-Style Solution

Old-School C++ Solution