Cast directly in foreach loop - c++

Question

In a certain situation I have an std::vector of pointers to ClassA. Another class, ClassB, inherits from ClassA. At some point I know this vector only contains pointers to instances of ClassB. I iterate over the vector with a foreach loop, after which I cast the object to ClassB.
Currently this looks similar to this:
Class ClassA
{
}
Class ClassB : public ClassA
{
public:
void DoSomething();
}
std::vector<ClassA*> vecA;
void iterate()
{
for(ClassA* obj : vecA)
{
((ClassB*)obj)->DoSomething();
}
}
I wonder if I can directly cast the object in the foreach loop. This would be shorter, and would not require me to cast the object every time I want to use it. I am looking for something that looks like this:
void iterate()
{
for((ClassB*)ClassA* obj : vecA)
{
obj->DoSomething();
}
}
Is this possible? And if it is not, what would be an easy way to 'save' the cast, if I want to use the casted object more than one time?
Thanks in advance.

Answer 1

void iterate() {
for(ClassA* obj_ : vecA) {
Assert(dynamic_cast<ClassB*>(obj_)); // debug build sanity check
auto* obj = static_cast<ClassB*>(obj_);
obj->DoSomething();
}
}

Answer 2

How about a container wrapper? Let's look at the usage first:
void iterate()
{
for (ClassB* obj : cast_range<ClassB*>(vecA))
{
obj->DoSomething();
}
}
And here is one possible implementation:
template<typename Target, typename Underlying>
struct cast_iterator_t
{
Underlying it;
Target operator*() const
{
return (Target) *it;
}
bool operator==(cast_iterator_t that) const
{
return it == that.it;
}
bool operator!=(cast_iterator_t that) const
{
return it != that.it;
}
cast_iterator_t& operator++()
{
++it;
return *this;
}
cast_iterator_t operator++(int)
{
cast_iterator_t old(*this);
++*this;
return old;
}
};
template<typename Target, typename Underlying>
cast_iterator_t<Target, Underlying> cast_iterator(Underlying it)
{
return {it};
}
template<typename Target, typename Range>
struct cast_range_t
{
Range& range;
decltype(cast_iterator<Target>(std::begin(range))) begin()
{
return cast_iterator<Target>(std::begin(range));
}
decltype(cast_iterator<Target>(std::end(range))) end()
{
return cast_iterator<Target>(std::end(range));
}
};
template<typename Target, typename Range>
cast_range_t<Target, Range> cast_range(Range& range)
{
return {range};
}