欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

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

程序员文章站 2023-02-08 08:06:08
重载运算符 关系,下标,递增减,成员访问的重载 为了演示关系,下标,递增减,成员访问的重载,创建了下面2个类。 1,类StrBlob重载了关系,下标运算符 2,类StrBlobPtr重载了递增,抵减,成员访问运算符 1,类StrBlob功能概要:类型与vector,但只能存放string类型的数据。 ......

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

为了演示关系,下标,递增减,成员访问的重载,创建了下面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

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

本人微信:xiaoshitou5854