Custom Iterator to pretend element is in vector - c++

Question

A class of element used to be stored in a vector with other similar elements.
But now, it been removed and moved into its own field in the parent object.
class OldParent {
vector<char> OldCollection = { 'A', 'B', 'C' };
}
class NewParent {
char A = 'A';
vector<char> NewCollection = { 'B', 'C' };
}
The type that is held by the vector is significantly more complicated than a character, it is a vector of a normalish struct.
So the actual original type would look something like this:
struct ActualType {
string val1;
int val2;
double val3;
}
vector<vector<ActualType>> OldCollection;
// vector that has been separated out
vector<ActualType> SeparatedCollection;
The problem is that alot of the original code uses iterators over the whole old collection and a clean way I thought I could implement this change would be to create an iterator that would work as if the separated field was never separated. This way much of the original code would not have to be changed.
However, I am definitely open to new ideas as well.
The use case looks like this:
The change means that one of the numbers will be permanently stored outside of the vector.
vector<int> nNums = {1,2,3};
void UseCase(int x)
{
int toRemove = 0;
for (auto& num : nNums)
{
if (num - x < 0)
{
toRemove++;
x -= num;
}
else
{
num -= x;
break;
}
for (int i = 0; i < toRemove; ++i)
nNums.erase(nNums.begin());
}
}

Answer 1

Here's a demo for a custom container that will take pointers to both the separated object and the container for the rest of the objects:
#include <vector>
#include <iostream>
#include <cmath>
template <typename T>
class CustomIterator;
template <typename T>
class CustomContainer
{
public:
CustomContainer(std::vector<T> *container, T *separated) : mContainer{container},
mSeparated{separated} {}
std::vector<T> *GetContainer() { return mContainer; }
T *GetSeparated() { return mSeparated; }
inline CustomIterator<T> begin() { return CustomIterator<T>(this); }
inline CustomIterator<T> end() { return CustomIterator<T>(this, mContainer->size() + 1); }
private:
std::vector<T> *mContainer;
T *mSeparated;
};
template <typename T>
class CustomIterator
{
public:
CustomIterator(CustomContainer<T> *container) : mCustomContainer{container}, mPos{0} {}
CustomIterator(CustomContainer<T> *container, int pos) : mCustomContainer{container}, mPos(pos) {}
CustomIterator(const CustomIterator<T> &other) = default;
const CustomContainer<T> *GetContainer() const { return mCustomContainer; }
const int GetPos() const { return mPos; }
~CustomIterator() {}
CustomIterator<T> &operator=(const CustomIterator<T> other)
{
mCustomContainer = other.GetContainer();
mPos = other.GetPos();
};
bool operator==(const CustomIterator<T> &other) { return other.GetContainer() == mCustomContainer && other.mPos == mPos; }
bool operator!=(const CustomIterator<T> &other) { return other.GetContainer() != mCustomContainer || other.mPos != mPos; }
CustomIterator<T> operator+=(const int &movement)
{
if (mPos + movement > mCustomContainer->GetContainer()->size() + 1)
mPos = mCustomContainer->GetContainer()->size() + 1;
else
mPos += movement;
return CustomIterator<T>(*this);
}
CustomIterator<T> operator-=(const int &movement)
{
if (mPos - movement < 0)
mPos = 0;
else
mPos -= movement;
return CustomIterator<T>(*this);
}
CustomIterator<T> operator++()
{
const auto maxSize = mCustomContainer->GetContainer()->size() + 1;
mPos = mPos == maxSize ? maxSize : mPos + 1;
return CustomIterator<T>(*this);
}
CustomIterator<T> operator--()
{
mPos = mPos == 0 ? 0 : mPos - 1;
return CustomIterator<T>(*this);
}
int operator-(const CustomIterator<T> &other) { return std::abs(other.GetPos() - mPos); }
T &operator*()
{
const auto maxSize = mCustomContainer->GetContainer()->size() + 1;
if (mPos == maxSize)
{
throw "Error: index out of bounds";
}
else if (mPos == 0)
{
return *(mCustomContainer->GetSeparated());
}
return (*mCustomContainer->GetContainer()).at(mPos - 1);
}
T &operator->() { this->operator*(); }
private:
CustomContainer<T> *mCustomContainer;
int mPos;
};
int main()
{
std::vector<int> container = {5, 6};
int separated = 4;
auto customContainer = CustomContainer<int>(&container, &separated);
for (auto i : customContainer)
{
std::cout << (i) << std::endl;
}
return 0;
}