L'allocation de structure de longueur variable membre du groupe

Je sais que je peux faire new char[n] pour créer un tableau de n caractères. Cela fonctionne même lorsque n n'est pas une compilation constante de temps.

Mais disons que je voulais une taille variable suivi de n caractères:

Ma première tentative à cet égard est la suivante:

struct Test
{
  std::size_t size;
  char a[];
};

Cependant, il semble new Test[n] ne fait pas ce que j'attends, et au lieu alloue n sizes.

J'ai également constaté que sizeof(std::string) est de 4 à ideone, de sorte qu'il semble qu'on puisse attribuer à la fois la taille et le char tableau dans un seul bloc.

Est-il un moyen que je puisse réaliser ce que j'ai décrit (sans doute ce que std::string déjà fait)?

Si vous utilisez VLAs c'est pas du C++. OK, je vois le titre qui a trompé moi.
Je pense que nous avons une série downvoter sur cette question, les réponses de...
Que penser d'un vecteur? Ou un membre de type string?
Assez facile à faire cuire votre propre classe qui alloue un tableau dynamique, mais quel est le problème avec juste l'aide de string ou vector<char>?
"sizeof(std::string) est de 4" - wat

OriginalL'auteur Clinton | 2011-10-03

  1. 11

    Pendant que vous peut le faire (et il a souvent été utilisé dans C dans une solution de contournement de toutes sortes), il est recommandé de ne pas le faire. Cependant, si c'est vraiment ce que vous voulez faire... voici une façon de le faire avec la plupart des compilateurs (y compris ceux qui ne jouent pas bien avec C99 améliorations).

    #define TEST_SIZE(x) (sizeof(Test) + (sizeof(char) * ((x) - 1)))

typedef struct tagTest
{
    size_t size;
    char a[1];
} Test;

int elements = 10; //or however many elements you want
Test *myTest = (Test *)malloc(TEST_SIZE(elements));

    Le C spécifications avant C99 ne permettent pas un zéro-longueur de la matrice au sein d'une structure. Pour contourner ce problème, un tableau à un seul élément est créé, et un de moins que la demande de l'élément de comptage est ajoutée à la taille de la structure réelle (la taille et le premier élément) pour créer la taille prévue.

    J'ai pu voir comment cela fonctionnerait dans ce cas, mais ne serait-ce pas un problème si le changement size_t avec short, et char à long, aboutissant à tous les longs n'étant pas alignés correctement (ou, sinon, de ne pas accorder assez d'espace)?
    Sauf si vous utilisez le compilateur directives pour définir manuellement l'emballage de la structure, si vous avez eu une short en tant que premier membre et défini la matrice comme long, le compilateur pourrait commencer à la short à l'octet 0 (par le biais de l'octet 1), passez octets 2 à 7, puis commencer à les long à l'octet 8 (en gardant correctement alignés). Ensuite, chaque long alloué/consulté après qui seraient sur un alignement de 8 octets.
    Adam: Ah oui, je vois maintenant.
    Cela fonctionne parce que sizeof(Test) permettra de résoudre à 8 (par mon commentaire ci-dessus), car la taille de la structure comprendra le vide octets utilisés pour l'alignement. Si vous avez essayé d'allouer à l'aide de sizeof(short) + (sizeof(long) * x), vous serait inévitablement allouer trop peu d'espace.
    Est-il de toute façon pour ce faire avec new, ou malloc est la seule option ici? (bien sûr, je vais l'envelopper le tout dans un constructeur, donc ce n'est pas un problème à l'aide de malloc, c'est juste par intérêt).

    OriginalL'auteur Adam Maras

  2. 9

    Vous pouvez utiliser placement new:

    #include <new>

struct Test {
    size_t size;
    char a[1];

    static Test* create(size_t size)
    {
        char* buf = new char[sizeof(Test) + size - 1];
        return ::new (buf) Test(size); 
    }

    Test(size_t s) : size(s)
    {
    }

    void destroy()
    {
        delete[] (char*)this;
    }
};

int main(int argc, char* argv[]) {
    Test* t = Test::create(23);
    //do whatever you want with t
    t->destroy();
}
    Miguel: que vous êtes l'allocation d'un tableau de char avec new, ne pouvait pas y avoir de problèmes potentiels avec l'alignement lorsque vous l'utilisez pour stocker une Test? Est-il de toute façon à forcer l'alignement sur new?
    Je ne pense pas qu'il y aura des problèmes d'alignement. Si le compilateur insère rembourrage dans la struct puis sizeof() rapport, de sorte que le remplissage sera compté dans la mémoire allouée avec new. Je pense que vous pourriez finir l'allocation de quelques octets supplémentaires avec cet algorithme, mais jamais moins.
    alloue de stockage correctement alignés pour tout type avec une taille égale ou inférieure à la taille demandée, ce qui n'est pas un problème ici. Cependant, l'accès à un tableau de l'indice est supérieure ou égale à sa taille est un comportement indéfini. Faites-en ce que vous voulez.
    Il serait la cause d'un comportement indéterminé si quelqu'un a essayé d'accéder à des éléments de t->a autres que t->a[0]

    OriginalL'auteur Miguel

  3. 7

    Vous pouvez également utiliser la fonction "Longueur 1 Tableau" truc. C'est dans C:

    struct Test {
    size_t size;
    char a[1];
}

int want_len = 2039;
struct Test *test = malloc(sizeof(struct Test) + (want_len - 1));
test->size = want_len;

    GCC prend également en charge "de longueur 0" tableaux pour exactement cet effet:
    http://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html

    Ceci est connu comme la "struct hack".

    OriginalL'auteur Yann Ramin

  4. 2

    Si je comprends bien, vous voulez une classe qui stocke un seul pointeur vers un allouée dynamiquement longueur de préfixe de la chaîne. Vous pouvez le faire en prenant avantage du fait que char* pouvez en toute sécurité alias quoi que ce soit.

    Une implémentation simpliste, juste pour montrer à quel il peut être fait:

    class LPS
{
private:
char* ptr;
public:
LPS() noexcept : ptr(nullptr) {} //empty string without allocation
explicit LPS(std::size_t len) {
//Allocate everything in one go
//new[] gives storage aligned for objects of the requested size or less
ptr = new char[sizeof(std::size_t) + len];
//Alias as size_t
//This is fine because size_t and char have standard layout
*reinterpret_cast<std::size_t*>(ptr) = len;
}
explicit LPS(char const* sz) {
std::size_t len = std::char_traits<char>::length(sz);
ptr = new char[sizeof(std::size_t) + len;
*reinterpret_cast<std::size_t*>(ptr) = len;
std::copy(sz, sz + len, ptr + sizeof(std::size_t));
}
LPS(LPS const& that) {
if(that.ptr) {
ptr = new char[sizeof(std::size_t) + that.size()];
std::copy(that.ptr, that.ptr + sizeof(std::size_t) + that.size(), ptr);
} else ptr = nullptr;
}
LPS(LPS&& that) noexcept {
ptr = that.ptr;
that.ptr = nullptr;
}
LPS& operator=(LPS that) {
swap(that);
return *this;
}
~LPS() noexcept {
//deleting a null pointer is harmless, no need to check
delete ptr;
}
void swap(LPS& that) noexcept {
std::swap(ptr, that.ptr);
}
std::size_t size() const noexcept {
if(!ptr) return 0;
return *reinterpret_cast<std::size_t const*>(ptr);
}
char* string() noexcept {
if(!ptr) return nullptr;
//the real string starts after the size prefix
return ptr + sizeof(std::size_t);
}
};
    Ce n'est pas l'adresse de l'OP de l'inquiétude au sujet de vouloir allouer la totalité de l'objet dans un tas de domaine (par opposition à l'allocation d'un objet sur le tas qui porte un pointeur vers un autre objet sur le tas, comme la plupart des classes de chaînes de caractères.)
    Je pense qu'il n'. Lit de la question "(...) il semble qu'on puisse attribuer à la fois la taille et le char tableau dans un seul bloc.", qui est exactement ce que ce n'. Je vais laisser les OP décider.
    Ne pas allouer l'objet de façon dynamique et tout à coup il y a une seule couche d'indirection. Comme la plupart des classes de corde: à qui std::unique_ptr<std::string>(new std::string)?

    OriginalL'auteur R. Martinho Fernandes

  5. 0

    Gardons les choses à court et doux en C++ à l'aide de std::vector.

    struct Test
{
std::size_t size;
char *a;  //Modified to pointer
Test( int size ): size(size), a(new char[size+1])
{}
};
std::vector<Test> objects(numberOfObjectsRequired,argumentToTheConstructor);
    N'est-ce pas allouer plusieurs tailles, et pas seulement un?
    Eh bien, quelqu'un est sur en bas à droit de vote de la spree.
    sizeof(size) est toujours le même, donc je ne pense pas a(new sizeof(size)) est ce que tu voulais dire (même si vous avez corrigé la syntaxe).
    Je vois ce que vous dites. J'ai juste fait une simple erreur stupide.
    Cela va à l'encontre du but de combiner les attributions de la structure et de la matrice.

    OriginalL'auteur Mahesh