/
将时 ,分,秒表示的时间用一个CTime类表示。
1）重载“>”和“<”实现当前时间对象表示的时间大于和小于某个对象的时间。
2）重载“==”实现当前时间对象表示的时间等于某个对象的时间。
3）重载“>>”实现按时间格式输入。
4）重载“<<”实现按时间格式输出。
5）析构函数：输出当前时间。
/
#include <iostreamh>
#include <ctime>
class CTime
{
public:
CTime();
~CTime();
bool operator >(CTime&);
bool operator <(CTime&);
bool operator ==(CTime&);
friend istream& operator >>(istream&,CTime&);
friend ostream& operator <<(ostream&,CTime&);
private:
int hour;
int minute;
int second;
};
CTime:: CTime()
{
this->hour = this->minute = this->second = 0;
}
CTime::~CTime()
{
char buffer[50];
time_t it=time(NULL);
strftime(buffer,50,"当前时间:%H:%M:%S",localtime(&it));
cout<<buffer<<endl;
}
bool CTime:: operator >(CTime& ct)
{
return (this->hour3600 + this->minute60 + this->second)
>
(cthour3600 + ctminute60 + ctsecond);
}
bool CTime:: operator <(CTime& ct)
{
return (this->hour3600 + this->minute60 + this->second)
<
(cthour3600 + ctminute60 + ctsecond);
}
bool CTime:: operator ==(CTime& ct)
{
return (this->hour3600 + this->minute60 + this->second)
==
(cthour3600 + ctminute60 + ctsecond);
}
istream& operator >>(istream& in,CTime& ct)
{
cout<<"hour:"; in>>cthour;
cout<<"minute:"; in>>ctminute;
cout<<"second:"; in>>ctsecond;
return in;
}
ostream& operator <<(ostream& out,CTime& ct)
{
out<<"time:"<<cthour<<":"<<ctminute<<":"<<ctsecond<<endl;
return out;
}
int main(int argc, char argv[])
{
CTime ct1 = CTime();
CTime ct2 = CTime();
cout<<"ct1:"<<endl;
cout<<"-------------"<<endl;
//3）重载“>>”实现按时间格式输入。
cin>>ct1;
//4）重载“<<”实现按时间格式输出。
cout<<ct1;
cout<<"-------------"<<endl;
cout<<"ct2:"<<endl;
cout<<"-------------"<<endl;
//3）重载“>>”实现按时间格式输入。
cin>>ct2;
//4）重载“<<”实现按时间格式输出。
cout<<ct2;
cout<<"-------------"<<endl;
//1）重载“>”和“<”实现当前时间对象表示的时间大于和小于某个对象的时间。
cout<<"ct1 > ct2:"<<(ct1 > ct2"true":"false")<<endl;
cout<<"ct1 < ct2:"<<(ct1 < ct2"true":"false")<<endl;
cout<<"-------------"<<endl;
//2）重载“==”实现当前时间对象表示的时间等于某个对象的时间。
cout<<"ct1 == ct1:"<<(ct1 == ct1"true":"false")<<endl;
cout<<"ct2 == ct2:"<<(ct2 == ct2"true":"false")<<endl;
cout<<"ct1 == ct2:"<<(ct1 == ct2"true":"false")<<endl;
cout<<"-------------"<<endl;
//5）析构函数：输出当前时间。
//ct1 和 ct2 被析构时实现
return 0;
}
/
test input:
12
44
30
16
33
22
test output:
ct1:
-------------
hour:12
minute:44
second:30
time:12:44:30
-------------
ct2:
-------------
hour:
16
minute:33
second:22
time:16:33:22
-------------
ct1 > ct2:false
ct1 < ct2:true
-------------
ct1 == ct1:true
ct2 == ct2:true
ct1 == ct2:false
-------------
当前时间:12:57:51
当前时间:12:57:51
/
简单的说，构造函数用来做新生成对象的初始化工作。在以往的设计中，由于没有给变量初始化而带来的麻烦在这里几乎没有了。析构函数与构造函数对应，主要做空间的释放工作。当然了，如果类中没有指针一类的需要创建空间的变量，那么析构函数意义就没有那么大了。不过为了规范期间，还是完整的写出为好。安全第一，你说呢？
下面给一个例子：
class A{
private:
char p;
public:
A(const char ptr);
~A();
//一些函数的声明
};
A::A(const char ptr){
p=new char [strlen[ptr]+1];//注意：这里给类里的指针变量申请空间
strcpy(p,ptr);//简单的拷贝动作
}
A::~A(){
if(p!=0) delete []p;//注意：如果指针不空，应该将指针指向的空间释放，看看格式。
}
//一些函数的定义
其实“派生”，跟“继承”是一回事，只是看它们的角度不一样而已
比如下面这段程序，我们可以说：
类Base派生了类Derived，也可以说类Derived继承了类Base
class Base
{
private:
int m_i;
};
class Derived : public Base
{
private:
int m_x;
};
下面是在百度上搜的啦，看看吧
作者：李强
继承性(inheritance)是面向对象程序设计语言的基本特征之一继承就是在已有类的基础上定义新的类新类继承已有类的部分或全部特征属性,并在此基础上定义新类的特有属性已有的类称为基类或父类,在它基础上建立的类称为派生类导出类子类
一继承的概念
继承类似生物学的分类概念如昆虫分为无翅和有翅,有翅又有蛾,苍蝇,蝴蝶等在c++语言中继承又分为单一继承和多重继承单一继承时,派生类只有一个基类多重继承时,派生类可以有若干个基类
单一继承:人类<-学生类,教师类
多重继承:学生类,男人类<-男学生
二派生类
class派生类名：继承方式 基类名{
private:
新增加的私有成员和声明语句；
protected:
新增加的保护成员和声明语句；
public:
新增加的公有成员和声明语句；
}
派生类名是新定义类的名字，该类是按指定的继承方式从基类中派生出来的，继承方式由private，protected，public三个关键字表示。
子类从父类中继承的所有成员都是父类中的 public成员,类的私有成员是不能够被继承
在c++语言中引入关键字protected定义类的保护成员，保护成员可以被子类所继承，并对子类可见的。
保护成员只对基类和子类可见的，不涉及继承问题，类中的保护成员与私有成员完全一致，但在继承中，对于派生类而言，保护成员与公有成员一致。通过保护成员可解决类类继承中的数据保护问题。
protected对于本类相当于私有成员，对于派生类相当于公有成员。
基类父类的私有成员 不可以 被派生类子类继承
基类父类的保护成员，公有成员 可以 被派生类子类继承
三派生类的继承方式
默认的派生方式说明为private，各种继承的特点如下：
1。私有继承：私有继承的特点是基类中的公有成员和保护成员作为派生类中的私有成员，不能够被派生类的子类所访问。在私有继承方式下，基类中的公有成员和保护成员只能够被直接派生类访问，不能够由派生类的子类再继承。
2。公有继承：公有继承的特点是基类中的公有成员和保护成员作为派生类中的公有成员和保护成员，但基类中的私有成员仍然是私有的（不可继承）。在公有继承方式下，基类成员的访问权限在派生类中保持不变，公有派生类的对象可以访问基类中的公有成员和保护成员；派生类的成员函数可以访问基类中的公有成员和保护成员。
3保护继承：特点是基类中的公有成员和保护成员都作为派生类中的保护成员，基类中私有成员仍然是私有的。
各种继承方式的保护属性
父类成员属性 公有继承 保护继承 私有继承
private 不可继承 不可继承 不可继承
proteceted proteceted private private
public public proteceted private
构造函数静态成员友员关系 不可继承 不可继承 不可继承
四。派生类的特性
1构造函数和析构函数
构造函数不能够继承，因此派生类的构造函数必须通过调用基类的构造函数来初始化对像，所以在派生类的构造函数中除了要完成对自身的数据成员的初始化外，还必须调用基类构造函数使基类的成员初始化。
派生类的成员是由基类中说明的成员和派生类中说明的成员共同构成。在c++语言中，将派生类的对象中由基类说明的成员相对独立成一个基类子对象，它由基类的构造函数初始化。
派生类名 （派生构造函数参数列表）：基类构造函数（基类构造函数参数列表1），
子对象名（基类构造函数参数列表2）
{
派生类成员初始化
}
派生类的析构函数应用的格式与构造函数一致，只不过析构函数前面要加~前缀。
构造函数的调用顺序：
对象（调用）—》基类构造函数-派生子类构造函数-派生父类构造函数
析构函数的调用顺序
对象（调用）—》派生父类构造函数-派生子类构造函数-基类构造函数
2构造函数之间的参数传递
已知在c++语言中，派生类不能继承基类的构造函数，但如有需要，从派生类的构造函数可以向基类的构造函数传递参数。
如果基类的构造函数带有参数，那么在派生类构造函数的形式参数中，除了要有初始化派生类本身所需要的形式参数外，还应当有初始化基类所需要的形式参数。这样就可以在派生类构造函数的说明时，将基类构造函数所要求的所有参数都传递过去。
派生类名（参数表）：基类名（基类析构函数参数表）
{
派生类析构函数体
}
复制初始化构造函数
类名::类名（类名&）
五。类生类的多重继承方式
class 派生类名：继承方式1 基类名1，继承方式2 基类名2。。。。。{
private：
新增加的私有成员声明语句
protected：
新增加的保护成员声明语句
public：
新增加的公有成员声明语句
}
六。虚基类
1类的重复继承问题
c++禁止的重复继承形式
B<- D-> B 子类D继承两下父类B
B<- D->C-> B 子类D直接继承父类B和间接继承父类B
c++允许的重复继承形式(间接派生两次甚至多次)
B<-C1<- D->C2-> B
学生人员管理系统
人员类：姓名，性别，年龄，系别等属性和 *** 作
学生类：人员类+专业，序号，职称等属性和 *** 作
教师类：人员类+专业，年级，学号等属性和 *** 作
进修的教师：它继承学生类和教师类，这样它重复继承了人员类
进修的教师：共享继承姓名和性别等（人员类）
复制继承了专业，作为学生类中的专业，作为教师类中的专业。
2类成员的二义性
既然c++语言允许重复继承，即允许一个派生类从多个父类中派生，而这多个父类又只有一个共同的基类，则在类成员的使用过程中就有可能产生二义性问题。
class Base{
public:int i;
}
class B1:public Base
{
public int j;
}
class B2:public Base
{
public int k;
}
class A:public B1,public B2
{
public :
int s;
inf fun();
}
int A::fun()
{
return (B1::i+B2::i);
}
main()
{
A d;
dB1::i=3;//语句1
dB2::i=6;//语句2
cout<<"i of B1="<
||类Base成员i
||类B1成员j
||类Base成员i
||类B2成员k
||类A成员s
由上图在派生类A的实例对象中存放两份从祖先类中继承的数据成员i，在程序中对对Base类的成员i的访问就有可能产生二义性。所以下面的程序段落中对i 的引用语句存在二义性错误。
A d;
di=3;//错误 无法确定路径
dbase::i=6;//错误 无法确定路径
正确的方法如语句1语句2
虚基类:为使公共基类在派生类的对象中只能生成一个拷贝，则应该将该公共基类说明为虚基类。说明方式如下
class 派生类名：virtual 继承方式 基类名{
虚拟基实体；
}
class student:virtual public person
{}
class teacher:virtual public person
{}
class_t_student: public student,public teacher
{}
t_student d;
int s="d"age;
问题一：普通函数就象你这样直接调用，但要注意，要先申明，在调用．申明格式就是直接在main()函数之前写下要调用的函数的返回值类型，函数名及参数．int max(int x,int y) ；这样就行．而构造函数是系统自己调用的，不需要你去调用，否则会出错．其他系统定义的函数要调用必须要有头文件，
例如：＃include<>
问题二：就是问题一所说的
问题三：构造方法没有返回值，不能重载，可有参数．
问题补充：上例的max()是自定义函数．你要想知道系统定义的函数有那些，上网一查就知道了．
附：你是学java的？我已经学过c++了，现在正学java ，希望以后能优势互补．愿意的话请留下QQ号！
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）