一、类和对象的基本概念
1. 类成员的可访问范围
在类的定义中，用下列访问范围关键字来说明类成员
可被访问的范围： – private: 私有成员，只能在成员函数内访问 – public : 公有成员，可以在任何地方访问 – protected: 保护成员，以后再说 以上三种关键字出现的次数和先后次序都没有限制。
定义一个类
class className {
private: // 说明类成员的可访问范围
私有属性和函数
public:
公有属性和函数
protected:
保护属性和函数
};
如过某个成员前面没有上述关键字，则缺省地被认为是私有成员。
class Man {
int nAge; // 私有成员
char szName[20]; // 私有成员
public:
void SetName(char * szName){
strcpy( Man::szName,szName);
}
};
在类的成员函数内部，能够访问：
– 当前对象的全部属性、函数；
– 同类其它对象的全部属性、函数。
在类的成员函数以外的地方，只能够访问该类对象的公有成员。
class CEmployee {
private:
char szName[30]; // 名字
public :
int salary; // 工资
void setName(char * name);
void getName(char * name);
void averageSalary(CEmployee e1,CEmployee e2);
};
void CEmployee::setName( char * name) {
strcpy( szName, name); //ok
}
void CEmployee::getName( char * name) {
strcpy( name,szName); //ok
}
void CEmployee::averageSalary(CEmployee e1,CEmployee e2){
cout << e1.szName; //ok ，访问同类其他对象私有成员
salary = (e1.salary + e2.salary )/2;
}
int main()
{
CEmployee e;
strcpy(e.szName,"Tom1234567889"); // 编译错，不能访问私有成员
e.setName( "Tom"); // ok
e.salary = 5000; //ok
return 0;
}
用struct定义类
和用"class"的唯一区别，就是未说明是公有还是私有的成员，就是公有
struct CEmployee {
char szName[30]; // 公有!!
public :
int salary; // 工资
void setName(char * name);
void getName(char * name);
void averageSalary(CEmployee e1,CEmployee e2);
};
2. 设置私有成员的机制，叫“隐藏”
“隐藏”的目的
强制对成员变量的访问一定要通过成员函数进行，那么以后成员变量的类型等属性修改后，只需要更改成员函数即可。
否则，所有直接访问成员变量的语句都需要修改。
“隐藏”的作用
如果将上面的程序移植到内存空间紧张的手持设备上，希望将szName 改为 char szName[5]，若szName不是私有，
那么就要找出所有类似 strcpy(e.szName,"Tom1234567889");这样的语句进行修改，以防止数组越界。这样做很麻烦。
如果将szName变为私有，那么程序中就不可能出现（除非在类的内部）strcpy(e.szName,"Tom1234567889");
这样的语句，所有对 szName的访问都是通过成员函数来进行，比如：e.setName( “Tom12345678909887”);
那么，就算szName改短了，上面的语句也不需要找出来修改，只要改 setName成员函数，在里面确保不越界就可以了。
3. 成员函数的重载及参数缺省
成员函数也可以重载
成员函数可以带缺省参数。
#include <iostream>
using namespace std;
class Location {
private :
int x, y;
public:
void init( int x=0 , int y = 0 );
void valueX( int val ) { x = val ;}
int valueX() { return x; }
};
void Location::init( int X, int Y)
{
x = X;
y = Y;
}
int main()
{
Location A,B;
A.init(5);
A.valueX(5);
cout << A.valueX(); // 输出：5
return 0;
}
使用缺省参数要注意避免有函数重载时的二义性
class Location {
private :
int x, y;
public:
void init( int x =0, int y = 0 );
void valueX( int val = 0) { x = val; }
int valueX() { return x; }
};
Location A;
A.valueX(); // 错误，编译器无法判断调用哪个valueX
二、构造函数
1. 基本概念
成员函数的一种
1).名字与类名相同，可以有参数，不能有返回值(void也不行)
2).作用是对对象进行初始化，如给成员变量赋初值
3).如果定义类时没写构造函数，则编译器生成一个默认的无参数的构造函数
4).默认构造函数无参数，不做任何操作
5).如果定义了构造函数，则编译器不生成默认的无参数的构造函数
6).对象生成时构造函数自动被调用。对象一旦生成，就再也不能在其上执行构造函数
7).一个类可以有多个构造函数
为什么需要构造函数：
1) 构造函数执行必要的初始化工作，有了构造函数，就不必专门再写初始化函数，也不用担心忘记调用初始化函数。
2) 有时对象没被初始化就使用，会导致程序出错。
A.默认无参数构造函数
class Complex {
private :
double real, imag;
public:
void Set( double r, double i);
}; //编译器自动生成默认构造函数
Complex c1; //默认构造函数被调用
Complex * pc = new Complex; //默认构造函数被调用
B.有参数的构造函数
class Complex {
private :
double real, imag;
public:
Complex( double r, double i = 0);
};
Complex::Complex( double r, double i) {
real = r; imag = i;
}
Complex c1; // error, 缺少构造函数的参数
Complex * pc = new Complex; // error, 没有参数
Complex c1(2); // OK
Complex c1(2,4), c2(3,5);
Complex * pc = new Complex(3,4);
C.可以有多个构造函数，参数个数或类型不同
class Complex {
private :
double real, imag;
public:
void Set( double r, double i );
Complex(double r, double i );
Complex(double r );
Complex(Complex c1, Complex c2);
};
Complex::Complex(double r, double i)
{
real = r; imag = i;
}
Complex::Complex(double r)
{
real = r; imag = 0;
}
Complex::Complex (Complex c1, Complex c2);
{
real = c1.real+c2.real;
imag = c1.imag+c2.imag;
}
Complex c1(3) , c2 (1,0), c3(c1,c2);
// c1 = {3, 0}, c2 = {1, 0}, c3 = {4, 0};
D.构造函数最好是public的，private构造函数不能直接用来初始化对象
class CSample{
private:
CSample() { }
};
int main(){
CSample Obj; //err. 唯一构造函数是private
return 0;
}
课堂例题：
有类A如下定义：
class A {
int v;
public:
A ( int n) { v = n; }
};
下面哪条语句是编译不会出错的？
A) A a1(3);
B) A a2;
C) A * p = new A();
D) A * a(3)
2. 构造函数在数组中的使用
class CSample {
int x;
public:
CSample() {
cout << "Constructor 1 Called" << endl;
}
CSample(int n) {
x = n;
cout << "Constructor 2 Called" << endl;
}
};
int main(){
CSample array1[2];
cout << "step1"<<endl;
CSample array2[2] = {4,5};
cout << "step2"<<endl;
CSample array3[2] = {3};
cout << "step3"<<endl;
CSample * array4 = new CSample[2];
delete []array4;
return 0;
}
输出：
Constructor 1 Called Constructor 1 Called step1 Constructor 2 Called Constructor 2 Called step2 Constructor 2 Called Constructor 1 Called step3 Constructor 1 Called Constructor 1 Called
代码示例：
class Test {
public:
Test( int n) { } //(1)
Test( int n, int m) { } //(2)
Test() { } //(3)
};
Test array1[3] = { 1, Test(1,2) };
// 三个元素分别用(1),(2),(3)初始化
Test array2[3] = { Test(2,3), Test(1,2) , 1};
// 三个元素分别用(2),(2),(1)初始化
Test * pArray[3] = { new Test(4), new Test(1,2) };
//两个元素分别用(1),(2) 初始化
课堂例题：
假设 A 是一个类的名字，下面的语句生成
了几个类A的对象？
A * arr[4] = { new A(), NULL,new A() };
A) 1
B) 4
C) 2
三、复制构造函数
四、类型转换构造函数和析构函数
五、构造函数和析构函数调用时机
RRR