这里边是我自己在下边学的时候练习的一些代码，有的简单，有的比较实用，我在前面建个目录，大家有想看的就直接根据目录找吧，直接放代码了。
目录
1、结构体与类
2、类的简单使用
3、变量间的引用
4、析构函数的使用
5、有默认参数的构造函数
6、转换构造函数-实复数相加
7、流提取运算符的重载
8、实复数的加减-运算符的重载
9、复数相加-无运算符重载
10、重载输出流运算符
11、复数相加-运算符的重载
12、单目运算符的重载-前置或后置++
1、结构体与类
#include <iostream>
using namespace std;
struct Student{ //c++中允许用struct去定义类，但对于私有公有须作出声明。
//private :
int num ;
char sex ;
};
int main()
{
Student s , *p;
s.num = 6 ;
p = &s ; //需作出这样的声明，不然指针不知道指向谁，就会出错。
p->sex = 's' ;
cout << s.num <<endl;
cout << p->sex <<endl;
return 0;
}
2、类的简单使用
#include <iostream>
using namespace std;
class Sturent {
private :
int num ;
string name ;
//char name1[10] ;
int sorce ;
public :
void display() ;
void set();
};
void Sturent::display(){
cout << "名次：" << num <<endl;
cout << "名字：" << name <<endl;
cout << "分数：" << sorce <<endl;
//cout << name1 ;
}
void Sturent::set(){
cin >> num ;
cin >> name ;
//cin >> name1 ;
cin >> sorce;
}
int main()
{
Sturent s ;
s.set();
s.display();
return 0 ;
}
3、变量间的引用
#include <iostream>
using namespace std;
int main()
{
int i;
const int &a=i ; //可以用const对引用加以限定，不允许改变引用的值。
//但可以改变引用所代表的变量的值。
i=3 ;
//a=2 ;
const int &b=a ;
// int &b=a ;
cout << "i=" << i <<endl;
cout << "b=" << b <<endl;
i=1 ;
cout << "a=" << a <<'\t'<< "i=" << i << '\t' << "b=" << b <<endl;
cout <<endl ;
//可以用常量或表达式对引用进行初始化，但必须用const作声明 。
const &o=i+5 ;
//编译系统中的处理： int temp = i+5 ; 先将表达式的值存放在临时变量temp中
// const &o = temp ; 声明o是temp的别名
//这是在内部实现的，用户不能访问临时变量。
cout << "i=" << i << '\t' << "o=" << o <<endl;
//可以利用这种方式实现数值间的类型转换。
double d=3.14 ;
double &p=d ;
int q ;
q = (int)d ; //这是显式声明，不加也是整型，为隐式
cout << "d=" << d << '\t' << "p=" << p << '\t' << "q=" << q <<endl;
return 0;
}
4、析构函数的使用
#include <iostream>
using namespace std ;
class Time{
int hour ;
int min ;
int sec ;
public:
Time(int h ,int m , int s ) : hour(h),min(m),sec(s){cout << "Start ";}
//根据输出显示，初始化表中的函数体部分先输出
//原因是在执行main函数时先建立了对象t1，在建立对象时调用了对象的构造函数
//故先输出cout的内容，然后调用对象的display函数，输出数值。
void display(){
cout << "时间： " << hour << ":" << min << ":" << sec << endl;
}
~Time(){ //定义析构函数
cout << "End 释放空间？" <<hour << endl; //输出有关消息
//加这个hour是看调用析构函数的顺序。（先进后出）
}
};
int main()
{
Time t1(1,1,1) ;
t1.display();
Time t2(0,0,0) ;
t2.display();
return 0 ;
}
5、有默认参数的构造函数
#include <iostream>
using namespace std;
class Time {
int hour ;
int min ;
int sec ;
public :
Time(int h=0 , int m=0 , int s=0) ;
void display(){
cout << "时间：" << hour << ":" << min << ":" << sec <<endl;
}
};
Time :: Time(int h , int m , int s){
hour = h ;
min = m ;
sec = s ;
}
int main()
{
Time t ;
t.display();
Time t1(1) ;
t1.display();
Time t2(1,2) ;
t2.display();
Time t3(1,2,3) ;
t3.display();
return 0;
}
6、转换构造函数-实复数相加
#include <iostream>
using namespace std;
class Complex{
double real ;
double imag ;
public:
Complex(){ //默认构造函数 无形参
real=0;
imag=0;
}
Complex(double r,double i):real(r),imag(i){} //实现初始化的构造函数，两个形参
Complex(int i){
real=i;
imag=0;
} //转换构造函数
/*类型转换函数的使用很容易造成二义性，考虑函数间的共存问题。*/
friend Complex operator+(Complex ,Complex );
void show(){
cout << "(" << real << "+" << imag << "i)" <<endl;
}
};
Complex operator+(Complex a,Complex b){
return Complex(a.real+b.real,a.imag+b.imag) ;
}
int main(){
Complex c1(1,1) ,c0 , c3(3) ,c2 , c4;
int i=4 ;
cout << "c1= ";c1.show();
cout << "c0= ";c0.show();
cout << "c3= ";c3.show();
cout << "c2= ";
c2=c1+c3 ;c2.show();
cout << "c4= ";
c4=c2+i;c4.show();//注意！！！这样写的时候上边的+重载函数的形参不能用引用！！！
//上下这两个之所以能够正常运行，是因为系统先用转换构造函数将建立一个临时对象Complex（i）
c4=i+c0;c4.show();
//实复数的交换律适用于+重载函数作为友员函数声明，而若作为成员函数声明仍然不可交换顺序。
}
7、流提取运算符的重载
#include <iostream>
using namespace std;
class Complex{
double real;
double imag;
public:
Complex (double r=0,double i=0):real(r),imag(i){}
/*流提取运算符的第一个形参和函数类型都必须是 istream& ，
和流插入运算符一样，都是为了能够持续输入输出，同样必须是作为友元函数。
*/
friend istream& operator >> (istream& , Complex&);
friend ostream& operator << (ostream& , Complex&);
void display(){
cout << "(" << real << "," << imag << "i)" << endl;
}
Complex operator++(){
return Complex(real++,imag) ;
}
};
istream& operator >> (istream& input, Complex& c){
input >> c.real >> c.imag ;
return input ;
}
ostream& operator << (ostream& output, Complex& c){
//这样写在输入虚数是负数时，会出错。
//output << "(" << c.real << "+" << c.imag << "i)" << endl;
//作为程序员，应该多考虑到各个情况。
output << "(" << c.real ;
if(c.imag>=0)
output << "+" ;
output<< c.imag << "i)" <<endl;
}
int main(){
Complex c1 , c2 ;
cout << "c1= " ;c1.display();
cout<<"重新输入 c1："<<endl;
cin>>c1 ;
cout << "c1=";
cout<<c1 ;
cout<<"输入 c2："<<endl;
cin>>c2;
cout << c2 ;
cout<<"c2自加后输出："<<endl;
++c2 ;
cout << c2 ;
}
8、实复数的加减-运算符的重载
#include <iostream>
using namespace std;
class Complex{
double real ;
double imag ;
public:
Complex(double r=0,double i=0):real(r),imag(i){}
void display(){
cout << "输出复数： " <<endl;
cout << "(" << real << "," << imag << "i)" << endl;
}
friend Complex operator+(int , Complex& ); //对+的二次重载，编译系统会根据
//表达式的形式选择调用与之匹配的运算符重载函数。
friend Complex operator+(Complex& , int );
};
Complex operator+(int i,Complex& a){
return Complex(i+a.real,a.imag) ;
}
Complex operator+(Complex& a,int i){
return Complex(i+a.real,a.imag) ;
}
int main(){
Complex C(1,2) , c2;
C.display();
int i ;
cout << "输入一个整数： " << endl;
cin >> i ;
c2=i+C ;
c2.display();
cout << "再输入一个整数： " << endl;
cin >> i ;
c2=C+i ;
c2.display();
}
9、复数相加-无运算符重载
#include <iostream>
using namespace std;
class Complex{
double real ;
double imag ;
public:
Complex(double r=0,double i=0):real(r),imag(i){}
Complex Complex_add(Complex &a);
void display();
};
Complex Complex::Complex_add(Complex &a){
Complex c ;
c.real=real+a.real ;
c.imag=imag+a.imag ;
return c ;
}
void Complex::display(){
cout << "(" << real << "," << imag << "i)" << endl;
}
int main()
{
Complex x1(1,1) , x2(2,2) , x3 ;
cout << "x1= " ;
x1.display();
cout << "x2= " ;
x2.display();
cout << "x3= " ;
x3.display();
cout << "用x3表示x1+x2的结果 ： "<<endl;
x3=x1.Complex_add(x2) ;
cout << "x1+x2= " ;
x3.display();
}
10、重载输出流运算符
#include <iostream>
using namespace std;
class Complex{
double real ;
double imag ;
public :
Complex(double r=0,double i=0):real(r),imag(i){}
Complex operator+(Complex& c){
return Complex(real+c.real,imag+c.imag) ;
}
friend ostream& operator<< (ostream& , Complex &c) ;
/*流插入运算符的重载函数只能作为友元函数来声明，不可是成员函数。
该重载函数的第一个参数和函数的类型都必须是ostream的引用，
是为了返回cout的当前值并便于连续输出。 */
void display(){
cout << "(" << real << "," << imag << "i)" <<endl;
}
};
ostream& operator<< (ostream& output , Complex &c){
//output是作为实参cout的形参传入，且共用一个地址。
output << "(" << c.real << "," << c.imag << "i)" <<endl;
return output ;
}
int main(){
Complex c1(1,1) , c2(2,2) , c3 ;
cout << "输出已有的两个复数： " << endl;
c1.display();c2.display();
cout << "两者相加： " <<endl;
c3=c1+c2 ;
cout << c3 ;
/*cout << c3 << 5 <<endl;
该行中只有第一个流插入运算符是被重载的，后边两个不是Complex类对象而是标准类型的数据
是用预定义的流插入符处理的
*/
/*还有一点需要注意：对于本题来说，流插入运算符的重载时作为Complex的友元函数来定义的
那只有在输出Complex类对象时才起到重载的作用
若 Time t ；
cout << t ; 这样是不对的，因为t是作为Time的类对象，不能使用用于Complex类的重载运算符
*/
}
11、复数相加-运算符的重载
#include <iostream>
using namespace std;
class Complex{
double real;
double imag;
public:
Complex(double r=0,double i=0):real(r),imag(i){}
Complex operator+(Complex &c2);
void display(){
cout << "("<< real << "," << imag << "i)" <<endl;
}
};
Complex Complex::operator+(Complex &c2){
Complex c;
c.real=real+c2.real ;
c.imag=imag+c2.imag;
return c ;
}
int main(){
Complex c , c1(1,1) , c2(2,2) ;
c1.display();
c2.display();
c=c1+c2 ;
cout << "c1+c2= " ;
c.display();
}
12、单目运算符的重载-前置或后置++
#include <iostream>
using namespace std;
class Time{
int hour ;
int min ;
int sec ;
public:
Time(int h=0,int m=0,int s=0):hour(h),min(m),sec(s){}
Time operator++(){
if(++sec>=60){
sec-=60 ;
min++ ;
}
return *this ;
}
Time operator++(int){
Time temp(*this);
sec++ ;
if(sec>=60){
sec-=60 ;
min++ ;
}
return temp ;
}
void display(){
cout << hour << ":" << min <<":" << sec << endl;
}
};
int main(){
Time t1(1,1,59) , t2 ;
cout << "t1: " ;t1.display();
cout << "t2: " ;t2.display();
++t1 ;
cout << "++t1: ";t1.display();
t2=t1++ ;
//t2=++t1 ;
cout << "t1++: ";t1.display();
cout << "t2: " ;t2.display();
}
