how to iterate struct in C++?

You can use std::bitset and have:

// 3 stands for 3 flags you have in your struct
std::bitset<3> flags;

flags.set(0); // set bit at position 0 to true
flags.set(2); // set bit at position 2 to true

and then you can loop through it:

for (std::size_t i{ 0 }; i < flags.size(); ++i) {
    // access with flags[i]
}

You can also create an enum for direct flag access like:

enum Flags {
    IsATrue = 0,
    IsBTrue,
    IsCTrue
};

and then use it like: flags[IsATrue].

If the number of values is fixed and known in advance, you can use array<bool>, otherwise use vector<bool>. Likewise for the is_true variable. Then you can easily loop over it.

One way is to use bitset as stated in other answer. But if structure Flags is something you have to use (from whatever reasons, for ex. maybe existing API, etc.), you can use operations wrapper and pointer to member to achieve "loop-ability". Something like (see Live):

struct Flags
{
    bool isATrue;
    bool isBTrue;
    bool isCTrue;
};

struct FlagsOp
{
    FlagsOp(Flags& f)
        : f{ f }
        , v({ &Flags::isATrue, &Flags::isBTrue, &Flags::isCTrue })
    {}
    size_t size() const { return v.size();}
    bool& operator[](size_t n) { return f.*(v[n]); }
private:
    Flags& f;
    vector<bool Flags::*> v;
};

int main()
{
    Flags f{};
    FlagsOp fop(f);

   fop[0] = true; // isATrue
   fop[1] = true; // isBTrue
   fop[2] = true; // isCTrue

    for (size_t i = 0; i < fop.size(); ++i)
        cout << fop[i] << '\n';
}

how to iterate struct in C++?

Same way as you would iterate anything that doesn't have a pre-existing standard iterator: By writing a custom iterator.

Writing custom iterators isn't simple, and writing this custom iterator is particularly complex due to lack of introspective language features, , . An incomplete, simplified example:

struct Flags
{
    bool isATrue;
    bool isBTrue;
    bool isCTrue;

    struct iterator {
        Flags* flags;
        int index;
        
        bool& operator*() {
            switch(index) {
                case 0: return flags->isATrue;
                case 1: return flags->isBTrue;
                case 2: return flags->isCTrue;
                default: throw std::out_of_range("You wrote a bug!");
            }
        }
        iterator& operator++() {
            index++;
            return *this;
        }
        iterator operator++(int) {
            iterator next = *this;
            index++;
            return next;
        }
        friend auto operator<=>(const iterator&, const iterator&) = default;
    };
    
    iterator begin() {
        return {this, 0};
    }
    iterator end() {
        return {this, 3};
    }
};

Note that although it is possible to iterate members of a class in C++, this is not necessarily efficient. It may be advisable to use an array instead of a class if you need efficient iteration.

If you do not want to change your struct Flags there is one other way. But first please read this And notice that this is not a portable solution. You can take advantage of unions by defining a union like this:

union Flagsunion{
    bool flag[sizeof(Flags)/ sizeof(bool)];
    Flags flags;
};

Assuming that the name of your std::vector<bool> is myvector and name of your Flags is myflags Then in your code:

    std::vector<bool> myvector;
    Flags myflags{ true, false, true};
    
    Flags2 my2ndflags;
    my2ndflags.flags = myflags;
    for(int i = 0; i < 3; ++ i){
        myvector.push_back(my2ndflags.flag[i]);
    }