本文主要是介绍C++捷径之五，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！
// 说明成员函数重载运算符
three_d operator=(three_d op2);//类中定义，=运算符重载
three_d three_d::operator ++()//前置++;++a
{
x++;
y++;
z++;
return *this;
}
three_d operator++(int notused);
three_d three_d::operator ++(int notused)//后置++；a++
{
three_d temp=*this;
x++;
y++;
z++;
return temp;
}
friend three_d operator++(three_d &op1);//声明为友元，必须加上three_d &op1，why?
friend three_d operator++(three_d &op1, int notused);//记住
friend three_d operator +(three_d op1,three_d op2);// 成员函数定义为友元
three_d operator +(three_d op1,three_d op2)//成员函数此时没有加作用域three_d::
{
three_d temp;
temp.x=op1.x+op2.x;
temp.y=op1.y+op2.y;
temp.z=op1.z+op2.z;
return temp;
}
#include <iostream>
#include <cstring>
#include <cstdlib>
using namespace std;
class sample{
char *s;
public:
static int elye;
sample() { s=new char('/0'); cout<<"Normal constructor."; }
sample(const sample &ob);
~sample() { if(s) delete []s; cout<<"Freeing s./n";}
void show() {cout<<s<<'/n';}
void set( char *str);
sample operator=(sample &ob);
};
int elye=0;
sample::sample(const sample &ob)
{
cout<<"Copy constructor./n";
s=new char[strlen(ob.s)+1];
strcpy(s, ob.s);
}
void sample::set(char *str)
{
s=new char[strlen(str)+1];
strcpy(s, str);
}
sample sample::operator =(sample &ob)
{
if(strlen(ob.s)>strlen(s))
{
delete []s;
s=new char[strlen(ob.s)+1];
}
strcpy(s,ob.s);
return *this;
}
sample input()
{
char instr[80];
sample str;
cout<<"Enter a string: ";
cin>>instr;
str.set(instr);
return str;
}
int main()
{
sample ob;
ob=input();
ob.show();
return 0;
}
//程序没有调试通过，说
//
int operator[](int i) { return a[i];}//类中[]说明，数组
ob[2]//等价于ob.operator [](2)
three_d operator()(int a,int b,int c);//类中()说明
ob2=ob1(10,11,12);
str_type(char *str="") {strcpy(string,str);//类中字符串构造函数
str_type a("Hello ")；//定义
//--程序＃1 说明继承的使用
class road_vehicle{…};
class truck: public road_vehicle{…};//truck是road_vehicle的派生类。私有不能直接调用
class derived:private base{…};//private派生，则基类中成员均为派生类的私有成员
base::set;//对于基类中定义的set()函数，使之派生类在私有派生情况下仍旧可用
class derived: protected base{…};// protected派生，则基类中成员均为派生类的私有成员
class derived: public base1,public base2{…};//多继承
//派生类的成员若于基类同名，则基于本身。即派生的对派生的，基的对基的
//基于保护的protected，被派生后相当于成为私有变量。
//说明构造和析构
class base{
//public:
protected:
base() { cout<<"Constructing base./n"; }
~base() { cout<<"Destructing base./n"; }
};
class derived: public base {
public:
derived() { cout<<"Constructing derived./n"; }
~derived() { cout<<"Destructing derived./n"; }
};
int main()
{
derived ob;
return 0;
}
//结果：Constructing base.
// Constructing derived.
// Destructing derived.
// Destructing base.
//先调用基类的构造函数，再调用派生类的，析构则相反。
//--程序＃12 说明传递参数给基类
derived(int x, int y): base(y){…};//base(y)为基类中定义
ob.derived1::i=10;//基类中成员的使用
class derived1: virtual public base{…};//虚基类
ob.i=10;//此时可以直接调用base中的成员，不需要ob.derived1::i=10
这篇关于C++捷径之五的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！
