How to construct a string by padding OR truncating another input string? - c++

Question

There are millions of answers about strings, but I cannot find one that fits my problem. I tried finding it in cppreference.com, but I cannot find a solution for this specific problem.
I know how to solve the problem in general - it works. But I want to learn more C++ and find a "proper" (efficient) solution. Maybe one of the C++ wizards can help me out :)
I have a struct that contains a double and a string (the name of a variable, for example). When I want to initialize the struct through the constructor, I want to make sure that the string in the struct has a fixed length. If it is too long, I want to truncate it, if it is too short, I want to pad it. I can use resize() for that.
I am searching for a way to efficiently do that in one step in the initializer list of the constructor, if possible. Is there some clever operation I am missing?
All I can come up with is to write it in the function body of the constructor:
#include <iostream>
#include <string>
using namespace std;
const uint STRING_LENGTH = 25;
struct parameter {
double value;
string name;
parameter(double _value, const string& _name)
: value(_value) // easy
{
string name_temp(_name);
name_temp.resize(STRING_LENGTH, ' ');
name = name_temp;
};
};
int main(int argc, char* argv[]) {
parameter A(0.5, "my_variable");
parameter B(-0.1, "my other variable with the name that is too long and has to be truncated!");
cout << "parameter name: " << A.name << "\tis:\t" << A.value << '\n';
cout << "parameter name: " << B.name << "\tis:\t" << B.value << '\n';
}

Answer 1

I like the resize trick, but removing the const& (so that the caller can std::move() the string in if they want to) might be a slightly better interface. Here there will be at most one copy in the actual function body (assuming the caller moved the string in), whereas in the original version there were three in the worst case.
parameter(double _value, string _name)
: value(_value), name(std::move(_name))
{
name.resize(STRING_LENGTH, ' ');
};

Answer 2

If you really want to handle this in the constructor's initialization list, write a helper function that it can call, eg:
std::string&& fix_length(std::string &&s) {
s.resize(STRING_LENGTH, ' ');
return std::move(s);
}
struct parameter {
double value;
std::string name;
parameter(double _value, std::string _name)
: value(_value), name(fix_length(std::move(_name)))
{
}
};
Online Demo
However, if you really need a fixed-length string, consider using std::array instead, eg:
class fixedString
{
std::array<char, STRING_LENGTH+1> cdata;
public:
fixedString(const std::string &s)
: fixedString(s.c_str(), s.size())
{
}
fixedString(const char *s)
: fixedString(s, std::strlen(s))
{
}
fixedString(const char *s, const size_t len)
{
std::copy_n(s, std::min<size_t>(len, STRING_LENGTH), cdata.begin());
if (len < STRING_LENGTH)
std::fill_n(cdata.begin()+len, STRING_LENGTH-len, ' ');
cdata[STRING_LENGTH] = '\0';
}
friend std::ostream& operator<<(std::ostream& os, const fixedString &fs)
{
os << fs.cdata.data();
return os;
}
};
struct parameter {
double value;
fixedString name;
parameter(double _value, const fixedString &_name)
: value(_value), name(_name)
{
}
};
Online Demo