La copie de boost::array<char> std::string

Je suis en train de cvopy boost::array<char> à std::string.

boost::array<char, 1024> _buffer;
std::string data;
std::copy(_buffer.begin(), _buffer.begin()+bytes_transferred, data.begin());

qui ne fonctionne pas. Alors je l'ai changé un peu.

char _buffer[1024];
std::string data;
std::copy(_buffer, _buffer+bytes_transferred, data.begin());

deuxième ne fonctionne pas non plus.

Alors, que voulez-vous dire par "ne fonctionne pas"?

OriginalL'auteur Dipro Sen | 2012-06-14

  1. 5

    Vous pouvez utiliser back_insert_iterator. En assignant à la il va appeler push_back en fonction du récipient de sorte que vous n'avez pas besoin de s'inquiéter avec l'allocation d'espace disque manuellement.

    std::copy(_buffer.begin(), _buffer.begin()+bytes_transferred, std::back_inserter(data));
    Bien que cela fonctionne, je pense que c'est beaucoup moins efficace que de simplement en utilisant le constructeur. Je doute que le compilateur est assez intelligent pour réaliser que l'on peut optimiser ce dans un bloc de copie de mémoire.
    Je suis d'accord. J'ai posté ce par souci d'exhaustivité souci, je suppose.

    OriginalL'auteur jrok

  2. 15

    Le problème ici est que copy suppose que l'espace existe déjà pour les données que vous avez écrit; il ne crée pas de nouvelles pour vous. Par conséquent, les deux morceaux de code provoquer un comportement non défini, puisque vous allez être la copie de personnages à un endroit où l'espace n'a pas été précédemment réservés.

    La meilleure façon de le faire serait d'utiliser le string constructeur:

    boost::array<char, 1024> _buffer;
std::string data(_buffer.begin(), _buffer.end());

    ou

    char _buffer[1024];
std::string data(_buffer, _buffer + 1024);

    Cela permettra d'initialiser la chaîne comme une copie des données stockées dans le tableau.

    Espérons que cette aide!

    Donc, Dois-je reserve() Si je veux utiliser std::copy ? et pourquoi ne pas std::copy crash ?
    Non, reserve va pas résoudre ce problème. Vous devez resize la chaîne de sorte qu'il n'y avait suffisamment d'espace avant d'utiliser std::copy. reserve sert une tout autre fonction. Quant à savoir pourquoi il n'y a pas de plantage, je n'ai absolument aucune idée. C'est un comportement indéfini, ce qui signifie que le programme peut faire quoi que ce soit. Ne pas s'écraser est parfaitement légal par le C++ spec.

    OriginalL'auteur templatetypedef