C++学习笔记三

11、重载性

1.构造函数能重载

2.析构函数不能重载

3.一般函数可以重载

#include<iostream.h>

class M

{

public:

M(int x,int y) { X = x; Y = y;}

M(int x) { X = x;Y = x*x;}

int add(int x,int y);

int add(int x);

int add();

int Xout() { return X; }

int Yout() { return Y; }

private:

int X,Y;

};

12、设置参数的缺省值

注意：缺省项的补足的原则：从左至右补充。

class N

{

public:

N(int a=3,int b=5,int c=7);

int Aout() {return A;}

int Bout() {return B;}

int Cout() {return C;}

private:

int A,B,C;

};

N X,Y(9,11),Z(13,15,17);

cout<<"Y="<<Y.Aout()<<", "<<Y.Bout()<<", "<<Y.Cout()<<endl;

输出结果： 9 ， 11， 7而不是 3 9 11

12、静态成员：

目的：解决数据共享问题，即不通过全局对象，而实现多个对象之间的数据共享。

注意：1、静态成员储存在一个地方，供所有的对象使用。

2、静态数据成员的值对每个对象都是一样的，但是其值可以被任何一个对象

更新。

使用方法与注意事项：

静态数据成员在定义或说明时前面加上关键字static：

private：

static int s; //s是私有的静态数据成员

class Myclass

{

public:

Myclass(int a,int b,int c);

void GetNumber();

void GetSum();

private:

int A,B,C;

static int Sum;

};

int Myclass::Sum = 0;

Myclass::Myclass(int a,int b,int c)//构造函数

{

A = a;

B = b;

C = c;

Sum += a + b + c;

}

M.GetSum(); //由于Sum是static变量，所以它的值可以在M、N两个对象共同调用。

N.GetSum();

注意：

1.初始化在类体外进行，前面不加static,以免与一般静态变量或对象混淆。

2.初始化时不加该成员的访问权限控制符(静态数据成员初始化位置与访问权限无关)；//?????????

3.初始化时使用作用域运算符表明它所属的类；//???????

4.引用格式： <类名>：：<静态成员名>

13、静态函数与静态变量：

#include<iostream.h>

class M{

public:

M(int a){ A = a;B += a;}

static void f1(M m); //公有静态成员函数

private:

int A;

static int B;
//私有静态成员函数

};

int M::B=0;

void M::f1(M m)

{

cout<<"A="<<m.A<<endl; //静态函数中药引用非静态变量，必须要通过对象引用

cout<<"B="<<B<<endl;
//静态函数可以直接引用静态变量

}

void main()

{

M P(5),Q(10);

M::f1(P); //调用静态成员函数

M::f1(Q);
//<类名>：<函数名>(参数列表)

}

总结：

a. 静态成员函数的实现不能直接引用类中说明的非静态成员，可以引用类中说明的静态成员。

b. 静态成员函数中要引用非静态成员时，可以通过对象来引用。

c. 调用静态成员函数的方式：

<类名>：<函数名>(参数列表)

14、静态函数变量商品实例（34_静态函数变量商品实例）

#include<iostream.h>

class Goods{

public:

Goods(int w);

~Goods();

int Weight();

static int TotalWeight();

private:

int weight;

static int totalWeight;

};

Goods::Goods(int w)

{

weight = w; //构造函数可以使用自己的私有成员

totalWeight += w;

}

int Goods::TotalWeight()

{

return totalWeight; //静态函数中的静态变量可以直接使用，内部的函数可以使用自身私有变量

} //但静态函数使用非静态变量是必须构造对象

Goods::~Goods()

{

totalWeight-=weight; //析构函数可以直接使用自己的私有成员

}

Goods::Weight()

{

return weight;

}

int Goods::totalWeight=0;

void main()

{

int w;

cin>>w;

Goods g1(w);

//Goods::TotalWeight(g1);

cout<<Goods::TotalWeight()<<endl;

cin>>w;

Goods g2(w);

//Goods::TotalWeight(g2);

cout<<Goods::TotalWeight()<<endl;

}

总结：

1.构造函数可以使用自己的私有成员

2.析构函数可以直接使用自己的私有成员

3.静态函数中的静态变量可以直接使用，内部的函数可以使用自身私有变量

但静态函数使用非静态变量是必须构造对象