Wie deklariere ich eine neue Zeichenfolge die gleiche Länge einer bekannten Const-Zeichenfolge?

Question

Ich habe mit:

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

Grund dafür ist, wenn ich:

string letters[THESAMELENGTH.length()]; 

ich eine nicht konstante Ausdruck Beschwerde erhalten.

Aber wenn ich:

string letters[12]; 

ich in Gefahr bin, um jede Instanz zu ändern, wenn die Führungs const string Größe ändert.

Aber es scheint dumm, eine Zeichenfolge zuzuweisen, wenn ich diese Einträge nicht verwenden möchte, ich möchte nur meine neu zugewiesene Zeichenfolge die gleiche Länge wie die zuvor zugewiesene Const-Zeichenfolge, dann mit anderen Werten füllen.

Wie empfehlen Sie, dass ich das anmutig und sicher mache?

Answer 1

Sie können

string letters(THESAMELENGTH.length(), ' '); // constructs the string with THESAMELENGTH.length() copies of character ' ' 

BTW: string letters[12]; bedeutet nicht das gleiche wie erwartet. Er deklariert ein Array von string, enthält 12 Elemente.

Answer 2

Ich möchte nur meine neu zugewiesene Zeichenfolge die gleiche Länge wie die zuvor zugewiesene Const-Zeichenfolge haben, dann füllen Sie mit anderen Werten.

Ein Teil des Grundes der string Klasse/Typ existiert, ist, so dass Sie keine Sorge um den Versuch, seine Länge zu verwalten. (Das Problem mit Arrays von char.)

Wenn Sie eine const std::string tmp haben, dann können Sie nichts zuweisen, nachdem es bereits initialisiert wurde. Z.B .:

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

Wie würden Sie empfehlen ich anmutig diese und sicher?

Wenn Sie auf eine bestimmte Größe wirklich Strings behalten möchten, unabhängig von ihrem Inhalt, man konnte immer resize Ihre string Variablen. Zum Beispiel:

// 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); 

jetzt Ihre word String eine Länge/Größe der MAX_STRING_LENGTH haben und etwas über das Ende abgeschnitten wird.

Dieses Beispiel stammt aus 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 

können Sie nicht nur einen String fragen Variable für seine Länge zur Compile-Zeit. Per Definition ist es unmöglich, den Wert einer Variablen oder Zustand eines gegebenen Programms für diese Angelegenheit zu kennen, während es nicht ausgeführt wird. Diese Frage ist nur zur Laufzeit sinnvoll.

Andere haben dies erwähnt, aber es scheint ein Problem mit Ihrem Verständnis von string letters[12]; zu sein. Das gibt Ihnen ein Array von string Typen, d. H. Sie erhalten Platz für 12 vollständige Zeichenfolgen (z. B. Wörter/Sätze/usw.), nicht nur Buchstaben.

Mit anderen Worten, könnten Sie tun:

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

So Ihre letters Variable sollte genauer (z words) etwas umbenannt werden.

Wenn Sie wirklich wollen Buchstaben (zB das vollständige Alphabet auf einem einzelnen String), können Sie so etwas tun könnte:

// 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]; 
// ... 

Es hängt alles davon ab, was Sie tun müssen, aber dies könnte eine gute sein Alternative.

Haftungsausschluss: Beachten Sie, dass es nicht wirklich meine Empfehlung ist, dass Sie dies tun. Sie sollten string s verwalten ihre eigene Länge. Wenn beispielsweise der Wert string tatsächlich kürzer als Ihr Limit ist, verursachen Sie, dass Ihre Variable mehr Speicherplatz/Speicher als benötigt benötigt. Wenn sie länger ist, wird sie immer noch abgeschnitten. Keine der Nebenwirkungen ist gut, IMHO.

Answer 3

Das erste, was Sie tun müssen, ist den Unterschied zwischen einer String-Länge und einer Array-Dimension zu verstehen.

std::string letters = "Hello"; 

erstellt eine einzelne string, die die Zeichen aus "Hello" enthält und Länge 5.

Im Vergleich

std::string letters[5]; 

erstellt ein Array von fünf verschiedenen Standards konstruierten Objekten vom Typ std::string. Es wird keine einzelne Zeichenfolge mit 5 Zeichen erstellt. Der Grund für die nicht konstante Beschwerde bei

std::string letters[THESAMELENGTH.length()]; 

tun, ist, dass der Bau von Arrays in Standard-C++ erforderlich ist, eine Länge an den Compiler bekannt, zu verwenden, während die Länge eines std::string zur Laufzeit bestimmt wird.

Wenn Sie einen String haben, und was andere Zeichenfolge mit der gleichen Länge zu erstellen, können Sie so etwas wie

std::string another_string(letters.length(), 'A'); 

tun, die einen einzelnen String erstellen wird die erforderliche Anzahl von Buchstaben 'A' enthält.

Es ist weitgehend sinnlos zu tun, was Sie suchen, wie ein std::string kann seine Länge sowieso dynamisch ändern, je nach Bedarf. Es gibt auch nichts, was ein std::string davon abhält, mehr zuzuteilen, als es benötigt (z.B. um mehrfache Erhöhungen seiner Länge vorzusehen).