Comment voulez-vous construire un std::string avec un intégré à null?

Si je veux construire un std::string avec une ligne comme:

std::string my_string("astd::string my_string("a\0b");
b");

Où je veux avoir trois caractères dans la chaîne résultante (a, null, b), je n'en obtenir un. Quelle est la bonne syntaxe?

Vous devrez être prudent avec cela. Si vous remplacez 'b' avec un caractère numérique, vous silencieusement créer la mauvaise chaîne. Voir: stackoverflow.com/questions/10220401/...

OriginalL'auteur Bill | 2008-10-02

c++null stdstring

120

Depuis C++14

nous avons été en mesure de créer littérale std::string

#include <iostream>
#include <string>

int main()
{
    using namespace std::string_literals;

    std::string s = "pl-#include <iostream>
#include <string>
int main()
{
using namespace std::string_literals;
std::string s = "pl-\0-op"s;    //<- Notice the "s" at the end
//This is a std::string literal not
//a C-String literal.
std::cout << s << "\n";
}
-op"s;    //<- Notice the "s" at the end
                                    //This is a std::string literal not
                                    //a C-String literal.
    std::cout << s << "\n";
}

Avant Le C++14

Le problème est le std::string constructeur qui prend un const char* suppose l'entrée est un C-string. C-les cordes sont \0 terminée et donc l'analyse s'arrête quand il atteint le \0 caractère.

Pour compenser cela, vous devez utiliser le constructeur qui construit la chaîne de caractères à partir d'un char array (pas un C-String). Elle prend deux paramètres - un pointeur vers le tableau et d'une longueur:

std::string   x("pqstd::string   x("pq\0rs");   //Two characters because input assumed to be C-String
std::string   x("pq\0rs",5); //5 Characters as the input is now a char array with 5 characters.
rs");   //Two characters because input assumed to be C-String
std::string   x("pqstd::string   x("pq\0rs");   //Two characters because input assumed to be C-String
std::string   x("pq\0rs",5); //5 Characters as the input is now a char array with 5 characters.
rs",5); //5 Characters as the input is now a char array with 5 characters.

Remarque: C++ std::string est PAS \0terminée (comme expliqué dans d'autres posts). Cependant, vous pouvez extraire un pointeur vers une mémoire tampon interne qui contient un C-String avec la méthode c_str().

Également vérifier Doug T répondre ci-dessous sur l'utilisation d'un vector<char>.

Également vérifier RiaD pour un C++14 solution.

mise à jour: comme du c++11 chaînes sont null. Cela étant dit, Loki le post reste valable.
Ils sont nul en termes de stockage, mais pas dans le sens qu'ils sont null significatifs de fin null (c'est à dire avec de la ficelle de la longueur de la définition de la sémantique), qui est le sens habituel du terme.
Bien expliqué. Je vous remercie.

OriginalL'auteur Martin York

22

Si vous faites de la manipulation comme vous le feriez avec un style c string (tableau de caractères) envisager d'utiliser
```
std::vector<char>
```
Vous avez plus de liberté à le traiter comme un tableau de la même manière que vous le feriez à un c-string. Vous pouvez utiliser la copie() pour copier une chaîne de caractères:
```
std::vector<char> vec(100)
strncpy(&vec[0], "blah blah blah", 100);
std::string vecAsStr( vec.begin(), vec.end());
```
et vous pouvez l'utiliser dans les mêmes endroits que vous pouvez utiliser c-strings
```
printf("%s" &vec[0])
vec[10] = 'printf("%s" &vec[0])
vec[10] = '\0';
vec[11] = 'b';
';
vec[11] = 'b';
```
Naturellement, cependant, vous souffre des mêmes problèmes que c-strings. Vous pouvez oublier votre null terminal ou écrire passé l'espace alloué.

Si vous dire d'essayer de coder les octets de la chaîne ( grpc octets est stocké sous forme de chaîne) utiliser la méthode du vecteur tel que spécifié dans la réponse, pas de la manière habituelle (voir ci-dessous) qui ne va PAS construire l'ensemble de la chaîne de byte *bytes = new byte[dataSize]; std::memcpy(bytes, image.data, dataSize * sizeof(byte)); std::string test(reinterpret_cast<char *>(bytes)); std::cout << "Encoded String length " << test.length() << std::endl;

OriginalL'auteur Doug T.
13

Je n'ai aucune idée de pourquoi vous voulez faire une telle chose, mais essayez ceci:
```
std::string my_string("astd::string my_string("a\0b", 3);
b", 3);
```
Quelles sont vos préoccupations pour ce faire? Êtes-vous en question la nécessité de stocker des "\ "0b" jamais? ou remet en question l'utilisation de std::string pour le stockage telle? Dans ce dernier cas, que suggérez-vous comme alternative?
Parce que les gens ont à travailler avec des données binaires, parfois?
ensuite, vous faites quelque chose de mal si vous êtes à stocker des données binaires comme une chaîne de caractères. C'est ce que vector<unsigned char> ou unsigned char * ont été inventés pour.
Je suis tombé sur ce, tout en essayant d'en apprendre plus sur la sécurité de chaînes de caractères. J'ai voulu tester mon code pour s'assurer qu'il fonctionne toujours, même si il lit un caractère nul dans pendant la lecture d'un fichier / network qu'il s'attend à des données textuelles. J'utilise std::string pour indiquer que les données doivent être considérées comme du simple texte, mais je suis en train de faire certains de hachage et je tiens à vous assurer que tout fonctionne encore avec des caractères null impliqués. Qui semble que l'utilisation d'un littéral de chaîne avec un intégré à caractère null.
Non, ce n'est pas vrai. Un \0 d'octets en une chaîne UTF-8 ne peut être NUL. Un multi-octets caractère codé, ils ne contiennent \0--ni aucun autre caractère ASCII pour cette question.

OriginalL'auteur 17 of 26

Quelles nouvelles capacités définies par l'utilisateur littéraux ajouter à C++? présente un élégant réponse: Définir

std::string operator "" _s(const char* str, size_t n) 
{ 
    return std::string(str, n); 
}

ensuite, vous pouvez créer votre chaîne de cette façon:

std::string my_string("astd::string my_string("a\0b"_s);
b"_s);

ou même ainsi:

auto my_string = "aauto my_string = "a\0b"_s;
b"_s;

Il y a un "style ancien" chemin:

#define S(s) s, sizeof s - 1 //trailing NUL does not belong to the string

ensuite, vous pouvez définir

std::string my_string(S("astd::string my_string(S("a\0b"));
b"));

OriginalL'auteur anonym

La suite...

std::string s;
s.push_back('a');
s.push_back('std::string s;
s.push_back('a');
s.push_back('\0');
s.push_back('b');
');
s.push_back('b');

Vous devez utiliser des parenthèses à la place des crochets.
jk, merci, j'ai corrigé...

OriginalL'auteur Andrew Stein

Vous devrez être prudent avec cela. Si vous remplacez 'b' avec un caractère numérique, vous silencieusement créer la mauvaise chaîne à l'aide de la plupart des méthodes. Voir: Règles pour le C++ littéraux de chaîne de caractère d'échappement.

Par exemple, j'ai laissé tomber cette innocente à la recherche extrait au moyen d'un programme

//Create '//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
' followed by '0' 40 times ;)
std::string str("//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
    std::cerr << c;
    //'Q' is way cooler than '//Create '\0' followed by '0' 40 times ;)
std::string str("\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00\00", 80);
std::cerr << "Entering loop.\n";
for (char & c : str) {
std::cerr << c;
//'Q' is way cooler than '\0' or '0'
c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
std::cerr << c;
}
std::cerr << "\n";
' or '0'
    c = 'Q';
}
std::cerr << "\n";
for (char & c : str) {
    std::cerr << c;
}
std::cerr << "\n";

Ici est ce que ce programme de sortie pour moi:

Entering loop.
Entering loop.

vector::_M_emplace_ba
QQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQQ

C'était ma première instruction d'impression deux fois, plusieurs caractères non imprimables, suivie par un retour à la ligne, suivie par quelque chose dans la mémoire interne, dont je viens de écrasait (et puis imprimé, montrant qu'il a été remplacé). Le pire de tout, même de la compilation avec complet et détaillé de gcc avertissements m'a donné aucune indication de quelque chose de mauvais, et l'exécution du programme par le biais de valgrind ne pas se plaindre d'une mauvaise mémoire des schémas d'accès. En d'autres termes, il est complètement indétectable par des outils modernes.

Vous pouvez obtenir ce même problème avec le beaucoup plus simple std::string("0", 100);, mais l'exemple ci-dessus est un peu plus délicat, et donc plus difficile à voir quel est le problème.

Heureusement, C++11 nous donne une bonne solution pour le problème à l'aide d'initialiseur de syntaxe de la liste. Cela vous évite d'avoir à spécifier le nombre de caractères (qui, comme je l'ai montré ci-dessus, vous pouvez le faire à tort), et évite de combiner échappé numéros. std::string str({'a', '\0', 'b'}) est sûr pour n'importe quelle chaîne de contenu, à la différence des versions qui prennent un tableau de char et une taille.

Dans le cadre de ma préparation pour ce post, j'ai envoyé un rapport de bug de gcc dans l'espoir qu'ils vont ajouter un avertissement pour rendre cela un peu plus sûr: gcc.gnu.org/bugzilla/show_bug.cgi?id=54924

OriginalL'auteur David Stone

En C++14, vous pouvez maintenant utiliser les littéraux

using namespace std::literals::string_literals;
std::string s = "ausing namespace std::literals::string_literals;
std::string s = "a\0b"s;
std::cout << s.size(); //3
b"s;
std::cout << s.size(); //3

et la 2e ligne peut également être écrite, bien plus à mon humble avis, comme auto s{"a\0b"s};
Belle réponse Merci.

OriginalL'auteur RiaD

1

Préférable d'utiliser std::vector<char> si cette question n'est pas seulement pour des fins éducatives.

OriginalL'auteur Harold Ekstrom

anonym la réponse est excellente, mais il y a un non-macro solution en C++98:

template <size_t N>
std::string RawString(const char (&ch)[N])
{
  return std::string(ch, N-1);  //Again, exclude trailing `null`
}

Avec cette fonction, RawString(/* literal */) va produire la même chaîne que S(/* literal */):

std::string my_string_t(RawString("astd::string my_string_t(RawString("a\0b"));
std::string my_string_m(S("a\0b"));
std::cout << "Using template: " << my_string_t << std::endl;
std::cout << "Using macro: " << my_string_m << std::endl;
b"));
std::string my_string_m(S("astd::string my_string_t(RawString("a\0b"));
std::string my_string_m(S("a\0b"));
std::cout << "Using template: " << my_string_t << std::endl;
std::cout << "Using macro: " << my_string_m << std::endl;
b"));
std::cout << "Using template: " << my_string_t << std::endl;
std::cout << "Using macro: " << my_string_m << std::endl;

En outre, il y a un problème avec la macro: l'expression n'est pas réellement un std::string comme l'écrit, et par conséquent ne peut pas être utilisé par exemple pour la simple affectation-initialisation:

std::string s = S("astd::string s = S("a\0b"); //ERROR!
b"); //ERROR!

...donc, il pourrait être préférable d'utiliser:

#define std::string(s, sizeof s - 1)

Évidemment que vous ne devez utiliser l'une ou l'autre solution dans votre projet et de l'appeler ce que vous pensez est approprié.

OriginalL'auteur Kyle Strand

-4

Je sais que c'est un temps cette question a été posée. Mais pour toute personne qui est d'avoir un problème similaire pourrait être intéressé par le code suivant.
```
CComBSTR(20,"mystring1CComBSTR(20,"mystring1\0mystring2\0")
mystring2CComBSTR(20,"mystring1\0mystring2\0")
")
```
Cette réponse est trop spécifique pour les plates-formes Microsoft et ne traite pas de la question d'origine (qui a demandé à propos de std::string).

OriginalL'auteur Dil09
-7

Presque toutes les implémentations de std::les chaînes de caractères sont nul, de sorte que vous ne devriez probablement pas le faire. Note qu'un "\0b" est en fait de quatre caractères à cause de l'automatique terminateur null (a, null, b, null). Si vous voulez vraiment faire cette pause et std::string du contrat, vous pouvez le faire:
```
std::string s("aab");
s.at(1) = 'std::string s("aab");
s.at(1) = '\0';
';
```
mais si vous le faites, tous vos amis vont se moquer de vous, vous ne trouverez jamais le vrai bonheur.

std::string n'est PAS nécessaire d'être une valeur NULL.
Il n'est pas nécessaire, mais dans presque toutes les implémentations, il est probablement en raison de la nécessité pour le c_str() accesseur pour vous fournir la valeur null équivalent.
Pour l'efficacité d'un caractère null être conservés sur le dos de la mémoire tampon de données. Mais aucun des opérations (c'est à dire des méthodes) sur une chaîne d'utiliser cette connaissance ou qui sont touchés par une chaîne de caractères contenant un caractère NUL. Le caractère NULL sera manipulé exactement de la même manière que n'importe quel autre caractère.
C'est pourquoi il est si drôle que la chaîne est std:: - son comportement n'est pas défini sur n'IMPORTE quelle plateforme.
Je souhaite user595447 était toujours là afin que je puisse leur demander à quoi ils ont pensé qu'ils étaient en train de parler.

OriginalL'auteur Jurney

Vous devez vous connecter pour publier un commentaire.