c++ 面向对象

 

1）处理复数的例子

#include<bits/stdc++.h>
using namespace std;
class Complex{    
    private:
        int x,y;
    
    public:
        Complex(int a=0,int b=0) //构造函数 
        {
            x=a;
            y=b;
        }
        
        void SetX(int a){x=a;}     //功能函数    
        void SetY(int a){y=a;}     //功能函数    
        int GetX(){return x;}    //功能函数
        int GetY(){return y;}   //功能函数
        void Print(){cout<<x<<"+"<<y<<"i"<<endl;}  //功能函数        
        
        Complex operator + (Complex r)  //运算符号重载入 
            {return Complex(x+r.x,y+r.y);}

        ~Complex(){    }      //析构函数，撤销实例。 
};


int main()
{  
    Complex x1(6,8),x2(1,2);//实例化两个对象x1,x2，相当于定义两个变量 
    
    cout<<x1.GetX()<<"+"<<x1.GetY()<<"i"<<endl;//调用实例对象中的功能解决问题 
    cout<<x2.GetX()<<"+"<<x2.GetY()<<"i"<<endl;
    
    x1.Print();
    x2.Print();
    
    Complex x3=x1+x2;
    x3.Print();
    
    return 0;
}//x1,x2,x3 离开作用域时，撤销实例，节省内存。 

 

2）使用自定义的map和queue处理双向宽搜的例子

#include<bits/stdc++.h>
using namespace std;
const int maxl = 2e5+10;

class Map{
    
    struct item{
        string key;int value;
    }d[maxl];
    
    int cnt;
    
    public:        
        int find(string x){
            for(int i=0;i<cnt;i++) if(d[i].key==x)
              return d[i].value;
            return -1;
        }
        
        static int end(){return -1;}
        
        void insert (string k,int v){
            d[cnt].key=k;d[cnt++].value=v;
        }
    
}s[2];//定义对象数组，对象类型是MAP。作者为什么把步数记MAP中，而不是队列中？ 

class Queue{
    
    string q[maxl];
    int head,tail;
    
    public:
        void pop(){++ head;}
        string front(){return q[head+1];}
        bool empty(){return head==tail;}
        void push(string x){q[++tail]=x;}
}q[2];//定义对象数组，对象类型是Queue。


string st0,st1;
int m;

string LtoR(string s,int L,int R){
    string t=s;
    char tmp=t[L];
    for(int i=L;i<R;++i) t[i]=t[i+1];
    t[R]=tmp;
    return t;
}

string RtoL(string s,int L,int R){
    string t=s;
    char tmp=t[R];
    for(int i=R;i>L;--i) t[i]=t[i-1];
    t[L]=tmp;
    return t;
}

bool check(string st,int p,int step){
    
    if(s[p].find(st)!=s[p].end()) return false;//产生的状态st在s[p]中已经存在，说明状态出现过了,不是新状态。  
    
    
    //程序会运行到这里时，说明产生的状态st在s[p]中不存在 
    ++step;
    
    if(s[p^1].find(st)==s[p].end())  //产生的状态st在对面s[p^1]中也不存在，说明是个新状态 
    {
        s[p].insert(st,step);//加入map 用于判断重复 ，顺便记录步数 
        q[p].push(st); // 加入队列 
        return false;  
    }
    
    
    //程序运行到这里时，说明产生的状态st在对面的map(s[p^1])中存在,说明双向bfs相遇了 
    cout<<s[p^1].find(st)+step<<endl;
    
    return true;//返回已经相遇了 
    
}


int main()
{
    cin>>st0>>st1;
    
    int len=st0.length();
    if(len!=st1.length()) {    cout<<-1<<endl;    return 0;}
    if(st0==st1) { cout<<0<<endl; return 0;    }
    
    cin>>m;
    s[0].insert(st0,0);s[1].insert(st1,0);
    q[0].push(st0);q[1].push(st1);
    
    for(int p=0;!(q[0].empty() && q[1].empty());p^=1)//交替使用两个队列进行宽搜 
    {
        string st=q[p].front();q[p].pop();
        int step=s[p].find(st);
        if(    
            // 如果某个正向操作的结果与对面的状态相遇    正向操作：LtoR[m,len-1]，RtoL[0,m]
            (p==0 && (  check(LtoR(st,m,len-1),p,step) || check(RtoL(st,0,m),p,step))      )  
              || 
            //或者如果某个反向操作的结果与对面的状态相遇  反向操作：LtoR[0,m]，RtoL[m,len-1] 
            (p==1 && (  check(LtoR(st,0,m),p,step)     || check(RtoL(st,m,len-1),p,step))  ) 
          )
            return 0;
            
    }    
    cout<<-1<<endl;
    return 0;

}

 3）模板

#include<bits/stdc++.h>
using namespace std;


template <typename T> //告诉编译器，类型T暂时不定，在调用时再定。

//定义一个函数模板 求三个数的最大值，这个三个数的类型为暂时不确定类型T 
T MaxV(T v1,T v2,T v3){
    T v=v1;
    if (v<v2) v=v2;
    if (v<v3) v=v3;
    return v;
}


int main()
{
    int a=1,b=2,c=3;
    cout<<MaxV(a,b,c)<<endl;//输出3个整型数的最大值

    double x=1.1452,y=3.24542,z=0.64643;
    cout<<MaxV(x,y,z)<<endl;//输出3个浮点数的最大值     
    
    string s1="hello",s2="ayaya",s3="byebye";
    cout<<MaxV(s1,s2,s3)<<endl;//输出3个字符串的最大值     
    
    
    
    return 0;

}

 4）对象实例化的几种方法

#include<bits/stdc++.h>
using namespace std;

struct P0 { int r, c;};

struct P1 {
    int r, c;    
    P1(int r, int c): r(r), c(c) { } //使用初始化列表给成员赋值。也是一种实例化对象的方法。 
    
    public:
        Print(){cout<<r<<" "<<c<<endl;}
};

struct P2 {
    int r, c; 
    P2(int r, int c){this->r=r;  this->c=c;}
        
    public:
        Print(){cout<<r<<" "<<c<<endl;}
};


int main() {
    
    P0 Pos01;             //定义，也叫实例化 
    Pos01.r=1,Pos01.c=2;  //给对象成员赋值
    cout<<Pos01.r<<" "<<Pos01.c<<endl; 
    
    P0 Pos02={3,4};     //定义并初始化
    cout<<Pos02.r<<" "<<Pos02.c<<endl;  
    
    P1 Pos11={5, 6};        //定义并初始化
    Pos11.Print();
    
    P1 Pos12(7, 8);            //定义并初始化
    Pos12.Print();
    
    P2 Pos21={9, 10};        //定义并初始化
    Pos21.Print();
    
    P2 Pos22(11, 12);        //定义并初始化
    Pos22.Print();
      
    return 0;
}