Passer std :: vector à une fonction externe

Vous savez ce que vous devez faire ... Créez un tableau temporaire de booléens et copiez les valeurs.

auto v = std::make_unique<bool>(bool_vector.size());
std::copy(bool_vector.begin(), bool_vector.end(), v.get());
print_c_bool(v.get(), bool_vector.size());

ou

auto v = new bool[bool_vector.size()];
std::copy(bool_vector.begin(), bool_vector.end(), v);
print_c_bool(v, bool_vector.size());
delete[] v;

p>

Je peux changer le type stocké dans le std :: vector , mais je ne peux pas m'échapper d'utiliser std :: vector .

Dans ce cas, vous n'avez pas de chance. std::vector ne stocke pas de tableau de booléens, ni ses data () ne renvoient un pointeur vers un tableau de booléens (comme tous les autres std :: vectors faire pour leur type de données respectif).

Vous pouvez jouer quelques tours et utiliser std::vector ou similaire, même si la taille correspond, un uint8_t * n'est pas un booléen * ! Étant donné que la fonction ne peut pas changer, vous ne pouvez éviter de violer l'alias strict qu'en copiant les données dans un tableau booléen.

Si vous vous souciez des performances, je vous suggère de ne pas utiliser std::vector . Par exemple, avez-vous vraiment besoin d'une taille dynamique? Sinon, utilisez un std :: array .

J'ai essayé de le faire fonctionner en utilisant votre exemple et la solution suivante (assez sale) a bien fonctionné:

std::vector<Bool> b_vec {true, false, false, true, false};
test_print(reinterpret_cast<bool*>(b_vec.data()), b_vec.size());

Le résultat que j'ai obtenu est:

0: vrai
1: faux
2: faux
3: vrai
4: faux

0: vrai
1: faux
2: faux
3: vrai
4: faux

Cependant, je ne sais pas s'il se comportera de la même manière sur tous les systèmes / plates-formes. Mais si vous n'avez pas l'intention de changer votre système / plate-forme et si cela fonctionne sur le vôtre, je pense que cela pourrait faire le travail même si c'est une solution assez sale.

En fait, si nous le pouvons garantir que sizeof (bool) == sizeof (uint8_t) et en supposant que true et false sont respectivement traités en mémoire comme des entiers 1 et 0 , cette solution fonctionnera, mais pas autrement.

J'espère que cela pourra vous aider.

EDIT: Remplacé uint8_t par type char .

EDIT2:

Une autre solution qui ne viole pas la règle stricte d'aliasing est celle qui Kamil Cuk a mentionné que c'était de créer un wrapper Bool et de toujours vérifier que sizeof (bool) == sizeof (Bool) .

Une implémentation possible (juste le code de base) peut être:

struct Bool
{
    bool v;

    Bool(bool bv=false) : v(bv)
    {}
};

Et alors vous pourrez écrire:

#include <iostream>
#include <vector>

void test_print(bool * arr, size_t s)
{
    for(unsigned int i = 0; i< s; ++i)
        std::cout << i << ": " << (arr[i]?"true\n":"false\n");
    std::cout << std::endl;
}

int main()
{
    bool b_arr[5] = {true, false, false, true, false};
    test_print(b_arr, 5);

    //std::vector <uint8_t> b_vec = {true, false, false, true, false}; // former proposal
    std::vector <char> b_vec = {true, false, false, true, false}; // new proposal
    test_print(reinterpret_cast<bool*>(b_vec.data()), b_vec.size());

    return 0;
}

Cela a fonctionné pour moi :)