c/c++ 重载运算符 关系，下标，递增减，成员访问的重载

重载运算符 关系，下标，递增减，成员访问的重载

为了演示关系，下标，递增减，成员访问的重载，创建了下面2个类。

1，类strblob重载了关系，下标运算符

2，类strblobptr重载了递增，抵减，成员访问运算符

1，类strblob功能概要：类型与vector，但只能存放string类型的数据。

2，类strblobptr功能概要：类型指针，指向类strblob中的某个元素。

注意点：

1，->的重载方法的返回值必须是指针。

2，系统无法区分是前置的递增还是后置的，为了区分，在重载后置的时候，加一个int类型的参数，就告诉编译器这个是后置的递增。

3，后置的递增或者抵减的重载方法的返回值必须是值，不能是引用或者指针。因为返回的是值类型，所以会在retern处调用拷贝构造函数。前置的是放回引用，所以就不会调用拷贝构造函数。所以，能调用前置的时候，就调用前置的

strblob.h

#ifndef __strblob_h__
#define __strblob_h__

#include <memory>
#include <string>
#include <vector>

class strblobptr;
class strblob{
  friend class strblobptr;
  friend bool operator==(const strblob&, const strblob&);
  friend bool operator!=(const strblob&, const strblob&);
 public:
  typedef std::vector<std::string>::size_type size_type;
  strblob();
  strblob(std::initializer_list<std::string>);
  size_type size() const{return data->size();}
  bool empty()const {return data->empty();}
  void push_back(const std::string& t){data->push_back(t);}
  void pop_back();
  std::string& front();
  std::string& back();

  std::string& operator[](size_type);
  const std::string& operator[](size_type)const;

  strblobptr begin();
  strblobptr end();

 private:
  std::shared_ptr<std::vector<std::string>> data;
  void check(size_type, const std::string&) const;
};
bool operator==(const strblob&, const strblob&);
bool operator!=(const strblob&, const strblob&);

#endif

github

strblob.cpp

#include "strblob.h"
//#include <iostream>
#include "strblobptr.h"

strblob::strblob() : data(std::make_shared<std::vector<std::string>>()){}
strblob::strblob(std::initializer_list<std::string> il) :
  data(std::make_shared<std::vector<std::string>>(il)){}

void strblob::check(size_type i, const std::string& msg)const{
  if(i >= data->size()){
    throw std::out_of_range(msg);
  }
}

std::string& strblob::front(){
  check(0, "front");
  return data->front();
}

std::string& strblob::back(){
  check(0, "back");
  return data->back();
}

void strblob::pop_back(){
  check(0, "pop_back");
  data->pop_back();
}
bool operator==(const strblob& lhs, const strblob& rhs){
  /*
  if(lhs.data->size() >=0 && lhs.data->size() == rhs.data->size()){
    for(int i = 0; i < lhs.data->size(); ++i){
      if((*lhs.data)[i] != (*rhs.data)[i]){
    return false;
      }
    }
    return true;
  }
  else{
    return false;
  }
  */
  return *lhs.data == *rhs.data;
  
}
bool operator!=(const strblob& lhs, const strblob& rhs){
  return !operator==(lhs, rhs);
}

std::string& strblob::operator[](size_type idx){
  return (*data)[idx];
}
const std::string& strblob::operator[](size_type idx)const{
  return (*data)[idx];
}


strblobptr strblob::begin(){
  auto b = strblobptr(*this);
  return b;
}
strblobptr strblob::end(){
  auto e = strblobptr(*this, data->size());
  return e;
}

github

strblobptr.h

#ifndef __strblobptr_h__
#define __strblobptr_h__

#include <memory>
#include <string>
#include <vector>
#include "strblob.h"

class strblob;
class strblobptr{
 public:
  strblobptr() : curr(0){}
  strblobptr(strblob& a, size_t sz = 0):wptr(a.data), curr(sz){}

  //方法get和重载*的效果是一样的
  std::string get(){
    auto ptr = check(curr, "get string value");
    return (*ptr)[curr];
  }
  
  //方法get和重载*的效果是一样的
  std::string& operator*(){
    auto p = check(curr, "get string value");
    return (*p)[curr];
  }
  std::string* operator->(){
    return & this->operator*();
  }
  
  strblobptr& operator++();
  strblobptr& operator--();
  strblobptr operator++(int);
  strblobptr operator--(int);

 private:
  std::shared_ptr<std::vector<std::string>>
    check(std::size_t, const std::string&) const;
  
  std::weak_ptr<std::vector<std::string>> wptr;
  std::size_t curr;
};

#endif

github

strblobptr.cpp

#include "strblobptr.h"

std::shared_ptr<std::vector<std::string>>
strblobptr::check(std::size_t i, const std::string& msg) const{
  auto ptr = wptr.lock();
  if(!ptr){
    throw std::runtime_error("unbound strblobptr");
  }
  if(i >= ptr->size()){
    throw std::out_of_range(msg);
  }
  return ptr;
}

//qianzhi
strblobptr& strblobptr::operator++(){
  check(curr, "will past end");
  ++curr;
  return *this;
}
//qianzhi
strblobptr& strblobptr::operator--(){
  --curr;
  check(curr, "will past begin");
  return *this;
}
//houzhi
strblobptr strblobptr::operator++(int){
  auto tmp = *this;
  ++*this;
  return tmp;
}
//houzhi
strblobptr strblobptr::operator--(int){
  auto tmp = *this;
  --*this;
  return tmp;
}

github

main方法

#include "strblob.h"
#include "strblobptr.h"
#include <iostream>

using namespace std;
int main(){
  strblob s1{"11", "22"};
  strblobptr p1 = s1.begin();
  strblobptr tm = ++p1;
  cout << tm->size() << endl;
  p1--;
  tm = p1;
  cout << *tm << endl;
}

编译方法：

g++ -g strblob.cpp strblobptr.cpp mainstrblobptr.cpp -std=c++11

c/c++ 学习互助qq群：877684253

本人微信：xiaoshitou5854