This program creates a vector of a union of double and unsigned long, which can be accessed as either a vector of doubles or a vector of longs.

union_vector.cpp

/* Copyright (C) 2015 Hans Ekkehard Plesser */

#include <vector>
#include <iostream>

union Elem
{
public:
  explicit Elem(double x): val_as_double(x) {}
  explicit Elem(unsigned long n): val_as_ulong(n) {}

  double val_as_double;
  unsigned long val_as_ulong;
};

class Foo: public std::vector<int>
{
public:
  void push_back(int i) { this->push_back(i); }
};


class DUVector //: public std::vector<Elem>
{  
private:
  typedef std::vector<Elem> VecType;
  
public:  
  class double_iterator
  {
  private:
    VecType::iterator pos_;

  public:
    double_iterator() {}
    double_iterator( const VecType::iterator& rhs ): pos_(rhs) {}

    double_iterator& operator++()
    {
      ++pos_;
      return *this;
    }

    double& operator*() { return pos_->val_as_double; }

    bool operator!=( const double_iterator& rhs ) { return pos_ != rhs.pos_; }
  };

  class ulong_iterator
  {
  private:
    VecType::iterator pos_;

  public:
    ulong_iterator() {}
    ulong_iterator( const VecType::iterator& rhs ): pos_(rhs) {}

    ulong_iterator& operator++()
    {
      ++pos_;
      return *this;
    }

    unsigned long& operator*() { return pos_->val_as_ulong; }

    bool operator!=( const ulong_iterator& rhs ) { return pos_ != rhs.pos_; }
  };

  void push_back(double x) { Elem e(x); data_.push_back(e); }
  void push_back(unsigned long n) { data_.push_back(Elem(n)); }

  const double_iterator& begin_double() { double_begin_ = data_.begin(); return double_begin_; }
  const double_iterator& end_double() { double_end_ = data_.end(); return double_end_; }

  const ulong_iterator& begin_ulong() { ulong_begin_ = data_.begin(); return ulong_begin_; }
  const ulong_iterator& end_ulong() { ulong_end_ = data_.end(); return ulong_end_; }

private:
  VecType data_;
  double_iterator double_begin_, double_end_;
  ulong_iterator ulong_begin_, ulong_end_;
};



int main()
{
  DUVector data;

  data.push_back(1.0);
  data.push_back(1UL);
  data.push_back(2.0);
  data.push_back(2UL);

  std::cout << "As doubles:" << std::endl;
  for ( DUVector::double_iterator di = data.begin_double(); di != data.end_double(); ++di )
    std::cout << *di << '\t';
  std::cout << std::endl;

  std::cout << "As ulongs:" << std::endl;
  for ( DUVector::ulong_iterator ui = data.begin_ulong(); ui != data.end_ulong(); ++ui )
    std::cout << *ui << '\t';
  std::cout << std::endl;

  return 0;
}