Why not add both a begin() and end() function to your class that simply return v.begin(); and return v.end();? (Assuming v is your vector.)

class MyVectorWrapper
{
public:
  // Give yourself the freedom to change underlying types later on:
  typedef vector<int>::const_iterator const_iterator;

  // Since you only want to read, only provide the const versions of begin/end:
  const_iterator begin() const { return v.begin(); }
  const_iterator end() const { return v.end(); }

private:
  // the underlying vector:
  vector<int> v;
}

Then you could iterate through your class like any other:

MyVectorWrapper myV;
for (MyVectorWrapper::const_iterator iter = myV.begin(); iter != myV.end(); ++i)
{
  // do something with iter:
}

It seems potentially unwise to give that much access to the vector, but if you re going to why not just return a pointer or reference to the vector? (Returning the vector itself is going to be potentially expensive.) Alternately, return a std::pair<> of iterators.

An iterator is just an indicator for one object; for example, a pointer can be a perfectly good random-access iterator. It doesn t carry information about what sort of container the object is in.

The STL introduced the idiom of using two iterators for describing a range. Since then begin() and end() are the getters. The advantage of this is that a simple pair of pointers into a C array can be used as perfect iterators. The disadvantage is that you need to carry around two objects. C++1x will, AFAIK, introduce a range concept to somewhat ease the latter.

It sounds like what you need to accomplish will be potential violation of the so called Law of Demeter. This law is often an overkill, but oftentimes it is reasonable to obey it. Although you may grant read-only access by giving out only const-iterators you are still at risk that your iterators will get invalidated (easily with vectors) without third party knowing it. As you can never predict how your program will evolve over-time it is better to avoid providing features that can be misused.
Common motto: make your class interface easy to use and hard to misuse. The second part is important for overall product quality.

More:

template <typename T,typename A = std::allocator<T>>
class yetAnotherVector
{
public:
 typedef std::_Vector_iterator<T, A> iterator;
protected:
 std::vector<T,A> mV;
public:
 void add(const T& t)
 {
  if(!isExist(t))mV.push_back(t);
 }
    bool isExist(const T& t)
 {
  std::vector<T,A>::iterator itr;
  for(itr = mV.begin(); itr != mV.end(); ++itr)
  {
   if((*itr) == t)
   {
    return true;
   }
  }
  return false;
 }
 iterator begin(void){return mV.begin();}
 iterator end(void){return mV.end();}
};