c++学习（三）

如果想在同类到多个对象之间实现数据共享，也不要用全局对象，可以使用静态到数据成员。它一关键字static开头。静态数据成员在内存中只占用一份空间，而不是每个对象都分别为它保留一份空间。静态数据成员可以初始化，但只能在类体外进行初始化。一般形式：数据类型名  类名：：静态数据成员名=初值；不必在初始化语句中加入static。

#include<iostream>
using namespace std;
class Box
{
    public:
        Box(int,int);
        int volume();
        static int height;
        int width;
        int length;
};
Box::Box(int w,int len)
{
width=w;
length=len;
}

int Box::volume()
{
return (height*width*length);
}

int Box::height=10;

int main()
{
Box a(13,24),b(12,35);
cout<<a.height<<endl;
cout<<b.height<<endl;
cout<<Box::height<<endl;
cout<<a.volume()<<endl;
cout<<b.volume()<<endl;
}

输出结果：
10
10
10
3120
4200

函数可以定义静态的，在类中声明函数的前面加static.静态成员函数是类到一部分，不是对象到一部分。如果在类外调用公用到静态成员函数，需要用类名和域名“::”.

与静态成员，静态成员函数到作用只是为了能处理静态数据成员

与非静态成员函数区别：静态成员函数有this指针，而 静态成员函数没有this指针。由此决定静态成员函数不能访问本类中到非静态成员。

#include<iostream>
using namespace std;
class Student{
    public:
        Student(int n,int a,float s):num(n),age(a),score(s){}
        void total();
        static float average();
    private:
        int num;
        int age;
        float score;
        static float sum;
        static int count;
};
void Student::total(){
sum+=score;
count++;
}
float Student::average()
{
return (sum/count);
}

float Student::sum=0;
int Student::count=0;

int main()
{
Student stud[3]={
Student(1001,18,70),
Student(1002,19,78),
Student(1003,20,98)
};
int n;
cout<<"please input the number of students: "<<endl;
cin>>n;
for(int i=0;i<n;i++)
stud[i].total();
cout<<"the average score of"<<n<<"student is"<<Student::average()<<endl;
return 0;
}

转换构造函数的作用是将一个其他类型的数据转黄成一个指定的类的对象。

默认构造函数：Complex（）{real=0;imag=0;}

用于初始化的构造函数:Complex(double r,double i){real=r;imag=i};

转换构造函数：Complex(double r){real=r,imag=0;}

转换构造函数式将double型的参数r转换成Complex类的对象，r作为附属的是不，虚部位0.

归纳起来三点：1、先声明一个类（如Complex类）

2、在这个类中定义一个只有一个参数的构造函数，参数的类型是需要转换的类型。

3、在该类的作用域内用执行形式进行转换。 类名 (指定类型的数据)
Complex （double r）

也可以将另一类的对象转换成转换构造函数所在的对象：

Teacher （Student &s）{num=s.num;strcpy(name,s.name);***=s.***;}

 

类型转换函数的作用是将一个类的对象转换成另一个类型的数据

在Complex类中定义类型转换函数：operator double(){return real;} 即函数返回double型变量real的值。作用是将一个Complex类对象转换为一个double型数据。

 

重载单目运算符：单目运算符只有一个操作数，因此运算符重载函数只有一个参数。如果重载函数作为成员函数，则可以省略此参数。如果自增或者自减在后置，增加int型参数。

#include<iostream>
using namespace std;
class Time{
    public:
        Time(){minute=0;sec=0;}
        Time(int m,int s){minute=m;sec=s;}
        Time operator ++();
        Time operator ++(int);
        void display(){cout<<minute<<":"<<sec<<endl;}
    private:
        int minute;
        int sec;
};

Time Time::operator ++()
{
    if(sec++>=60)
    sec-=60;
    minute++;
    return *this; //返回当前值
}

Time Time::operator ++(int)
{
Time temp(*this); //复制流
sec++;
if(sec>=60)
{sec-=60;
minute++;}
return temp;
}
 int main()
{
Time t1(34,0);
for(int i=0;i<61;i++)
{
++t1;
t1.display();
cout<<"endl"<<endl;
t1++;
t1.display();
}
}

重载流插入运算和流提取运算符：用户自己定义的数据是不能直接用“<<”和“>>”来输入和输出，如果想用它们输入和输出自己声明的类型的数据必须对它们进行重载：

istream & operator >>(istream &,自定义 &)；

ostream & operator <<(ostream &,自定义 &)；

只能将重载“>>”和“<<”的函数作为友元函数或普通函数，而不能将它们定义为成员函数。

 

#include<iostream>
using namespace std;
class Complex{
    public:
        friend ostream & operator <<(ostream &,Complex &);
        friend istream & operator >>(istream &,Complex &);
    private:
        double real;
        double imag;
};

ostream & operator <<(ostream &output,Complex &c)
{
output<<"("<<c.real;
if(c.imag>=0)
output<<"+";
output<<c.imag<<"i)"<<endl;
return output;
}

istream & operator >>(istream &input,Complex &c)
{
cout<<"input part number: ";
input>>c.real>>c.imag;
return input;
}

int main()
{
Complex c1,c2;
cin>>c1>>c2;
cout<<"c1: "<<c1<<endl;
cout<<"c2: "<<c2<<endl;
return 0;
}