How do I declare a new string the same length of a known const string?

I've been using:

string letters = THESAMELENGTH; // Assign for allocation purposes.

Reason being, if I:

string letters[THESAMELENGTH.length()];

I get a non constant expression complaint.

But if I:

string letters[12];

I'm at risk of needing to change every instance if the guide const string changes size.

But it seems foolish to assign a string when I won't use those entries, I only want my newly assigned string to be the same length as the previously assigned const string, then fill with different values.

How do you recommend I do this gracefully and safely?

Solution

I only want my newly assigned string to be the same length as the previously assigned const string, then fill with different values.

Part of the reason the string class/type exists is so you don't have to worry about trying to manage its length. (The problem with arrays of char.)

If you have a const std::string tmp then you can't just assign anything to it after it has already been initialized. E.g.:

const std::string tmp = "A value";  // initialization
tmp = "Another value";              // compile error

How do you recommend I do this gracefully and safely?

If you really want to keep strings to a specific size, regardless of their contents, you could always resize your string variables. For example:

// in some constants.h file
const int MAX_STRING_LENGTH = 16;

// in other files
#include "constants.h"
// ...
std::string word = ... // some unknown string
word.resize(MAX_STRING_LENGTH);

Now your word string will have a length/size of MAX_STRING_LENGTH and anything beyond the end gets truncated.

This example is from C++ Reference

// resizing string
#include <iostream>
#include <string>

int main ()
{
  std::string str ("I like to code in C");
  std::cout << str << '\n';

  unsigned sz = str.size();

  str.resize (sz+2,'+');
  std::cout << str << '\n';

  str.resize (14);
  std::cout << str << '\n';
  return 0;
}

// program output
I like to code in C
I like to code in C++
I like to code

You can't just ask a string variable for its length at compile-time. By definition, it's impossible to know the value of a variable, or the state of any given program for that matter, while it's not running. This question only makes sense at run-time.

Others have mentioned this, but there seems to be an issue with your understanding of string letters[12];. That gives you an array of string types, i.e. you get space for 12 full strings (e.g. words/sentences/etc), not just letters.

In other words, you could do:

for(size_t i = 0; i < letters.size(); ++i)
    letters[i] = "Hello, world!";

So your letters variable should be renamed to something more accurate (e.g. words).

If you really want letters (e.g. the full alphabet on a single string), you could do something like this:

// constants.h
const std::string ALPHABET_LC = "abc...z";
const std::string ALPHABET_UC = "ABC...Z";
const int LETTER_A = 0;
const int LETTER_B = 1;
// ...

// main.cpp, etc.
char a = ALPHABET_LC[LETTER_A];
char B = ALPHABET_UC[LETTER_B];
// ...

It all depends on what you need to do, but this might be a good alternative.

Disclaimer: Note that it's not really my recommendation that you do this. You should let strings manage their own length. For example, if the string value is actually shorter than your limit, you're causing your variable to use more space/memory than needed, and if it's longer, you're still truncating it. Neither side-effect is good, IMHO.