Как получить те элементы вектора, где другой вектор имеет «1» в соответствующих индексах

Очевидно, что здесь предпочтительнее использовать простой цикл for, а не какой-либо алгоритм STL.

Но просто как доказательство концепции можно взять здесь stl::equals и лямбду из C++11:

std::equal(myVec.begin(), myVec.end(), markedToBeRead.begin(), [&](float item, int mark)->bool {
    if (mark)
        myResult.push_back(item);
    return true;
});

Это работает, но выглядит некрасиво.

Вот как я бы написал алгоритм для этого:

template <typename I, typename O, typename M>
void mask_copy(I begin, I end, O obegin, M mbegin) {
    for (; begin != end; ++begin, ++mbegin)
        if (*mbegin)
            *obegin++ = *begin;
}

Вызывается так:

int a[] = { 1, 2, 3, 4, 5, 6, 7, 8 , 9 };
bool m[] = { true, false, false, false, true, false, false, true, false };

std::vector<int> out;
mask_copy(begin(a), end(a), back_inserter(out), begin(m));

(Требуется C++11 для std::begin и std::end.)

Тем не менее, правильная реализация в библиотеке, вероятно, будет использовать enable_if (или static_assert), чтобы гарантировать, что используемые типы итераторов совместимы с его использованием, т. е. что I является входным итератором, O совместимым выходным итератором. и M итератор ввода, у которого value_type равно bool. К сожалению, отсутствие концепций приводит к настоящему взрыву шаблона.

С функциональной точки зрения это просто: это zip-архив двух входных диапазонов, за которым следует фильтр на отметке, равной 1, а затем карта для извлечения только значения.

К сожалению, стандартные алгоритмы C++ не очень хорошо подходят для композиции. Если вы не возражаете против создания промежуточных контейнеров, вы можете применить двоичную версию transform, за которой следует copy_if (или remove_copy_if в C++03 с обратным предикатом, или remove_if, чтобы изменить ваш промежуточный контейнер на месте), а затем унарная версия transform.

В качестве альтернативы Boost предоставляет первые две операции в виде адаптеров итераторов. Что-то вроде этого (не проверено):

struct marked {
    bool operator()(boost::tuple<int, float> t) {
        return t.get<0>() == 1;
    }
};

auto first = boost::make_zip_iterator(boost::make_tuple(markedToBeRead.begin(), myVec.begin());
auto last = boost::make_zip_iterator(boost::make_tuple(markedToBeRead.end(), myVec.end());

std::transform(
    boost::make_filter_iterator<marked>(first, last),
    boost::make_filter_iterator<marked>(last, last),
    std::back_inserter(myResults);
    [](boost:tuple<int, float> t) { return t.get<1>(); }
);

Вы, вероятно, уже убедились (а) что цикл лучше, и (б) замена циклов другими конструкциями — это что-то вроде зрелищного спорта в C++ ;-)

Если вам нужно связать дальнейшие операции, то std::transform также можно заменить адаптером итератора: transform_iterator.

что-то вроде этого?

for (unsigned int i = 0; i < myVec.length(); i++)
    if (markedToBeRead[i] == 1)
        myResult.push_back(myVec[i]);

Это работает для меня:

#include <algorithm>
#include <iostream>
#include <vector>

int main()  {
        std::vector<int>   markedToBeRead = {  1,1,0,0,1,0,1 };
        std::vector<float> myVec = { 1, 2, 3, 4, 5, 6, 7};

        // copy
        std::vector<float> result;
        std::copy_if(myVec.begin(), myVec.end(),
                std::back_inserter(result), [&](const float & f) {
                        return markedToBeRead[&f - &myVec[0]] == 1;
                });

        // Check result
        for (std::vector<float>::size_type i = 0; i < result.size(); ++i)
                std::cout << result[i] << " ";
}

Проверено на Ideone.