// 说明成员函数重载运算符
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