Conversion d'un conteneur std :: vector en un std :: set à l'aide de std :: transform

Il y a deux choses que vous pouvez faire ici.

1. Si vous possédez la définition de SomeStruct , il est préférable de remplacer ce membre par std :: string .
2. En bref, voyez si vous lambda pouvez prendre le paramètre by-ref const auto & obj . Cela ne créera pas de copie et ne pointera pas vers l'objet du conteneur. Cependant, j'ai toujours peur de cette solution car cela sent le mauvais design de classe où la propriété et la durée de vie des membres sont ambiguës.

Vous ne pouvez probablement pas créer un ensemble de char * à moins que toutes les instances de extensionName avec la même valeur pointent vers le même tableau de caractères (cela stockerait des pointeurs uniques à la place de valeurs uniques). Si vous utilisez à la place std::set<:string> , cela fonctionnera à la fois et ne stockera que des valeurs uniques et résoudra votre problème de durée de vie variable comme std :: string prend soin de se copier (ou déplacer) pour vous si nécessaire:

auto lambdaFn = 
    [](const SomeStruct& x) { return std::string(x.extensionName); };
std::set<std::string> xs;
std::transform(availableExtensions.begin(),
                availableExtensions.end(),
                std::inserter(xs, xs.begin()),
                lambdaFn);

Une façon de faire ce que vous voulez est d'utiliser le lambda suivant

const char* str = "Hello World!";

Le problème avec ceci est que vous enregistrez des pointeurs vers la mémoire appartenant à quelqu'un d'autre (ces chaînes). Lorsqu'ils sont détruits (cela semble être le cas à la fin de la fonction), le pointeur sera suspendu. Vous pouvez contourner cela en allouant de la mémoire dans votre lambda et en copiant les données:

auto lambda = [](const SomeStruct & x) -> const char* {
    char* c = new char[x.extensions.length()+1]; 
    std::strcpy(c, x.extensions.data()); 
    return c;
}

Mais alors vous devez faire la gestion de la mémoire vous-même (c'est-à-dire n'oubliez pas de libérer ces const char * ). Et c'est une mauvaise idée. Vous devriez probablement reconsidérer ce que vous faites. Pourquoi utilisez-vous const char * ici et non std :: string ?

N'oubliez pas que l'utilisation typique de const char * est de sauvegarder les littéraux de chaîne i C-code, c'est-à-dire le code

auto lambda = [](const SomeStruct& x) -> const char* { return x.extensions.data();};

crée un tableau char de taille suffisante dans la section statique de la mémoire, l'initialise avec la chaîne (une constante de temps de compilation) puis enregistre un pointeur vers celui dans str code >. C'est aussi pourquoi cela doit être un const char * car un autre pointeur faisant référence à un littéral de chaîne égal peut (ou non) pointer exactement le même tableau de caractères et vous ne voulez pas activer le changement là. Alors n'utilisez pas simplement const char * car vous voyez des chaînes en C enregistrées dans ces const char * sans que personne n'ait besoin de les libérer plus tard.

p >