C++类与对象

类与对象

类的定义

类定义的格式

class A{
	private: ;//私有成员，默认情况是私有
	public: ;//公有成员
	protected: ;//受保护成员
};

注意：1.类定义的时候不能初始化数据成员
2.类的数据成员可以是任何类型，但是不能是自动（auto）、寄存器(register)或外部(extern)进行说明。

类中成员函数的定义

类外定义：

返回值类型 类名：：成员函数名（形式参数表）
{
}

以内联函数的形式进行说明：

两种格式：
1.在类中定义的成员函数

class A
{
private:
	int x,y;
public:
	void set(int a,int b){x=a,y=b;}
};

2.在类外定义，但在函数名头前加上了inline关键字。
格式：inline 返回值类型 类名：：成员函数名（参数表）

class A
{
private:
	int x,y;
public:
	inline void set(int,int);
};
inline void A::set(int a,int b){x=a,y=b;}

内联函数的使用：
1.内联函数实现代码替换，提高运行效率
2.代码量小，且不含循环和开关语句

this 指针

特点：
1.this 是成员函数所属对象的指针，指向对象的地址。
2.this指针是一种隐含的指针，隐含于每一个类的成员函数。
3.this指针可以隐式调用，也可以显式调用，显式调用的格式：this->成员名
注意：this指针是系统自定义的，用户不能再定义。

类中数据成员的初始化

1.构造函数的函数体中。
2.构造初始化列表
格式：类名：：构造函数（参数总表）：变量1（初始值1），变量2（初始值2），变量3（初始值3）……

class A
{
private:
	int x;
	int ℞
	const float pi;
public: 
	A(int x1):x(x1),rx(x),pi(3.14)//rx(x)相当于rx=x,pi(3.14)相当于pi=3.14
};

注意：初始化的次序取决于类定义的声明次序，与成员初始化列表次序无关。

对象

对象的定义：

1.在声明类的同时，直接定义对象

class A
{
	……
}a,b; //a和b是A类的对象

2.声明了类之后，在使用时再定义对象

class A
{
	……
};
void main()
{
	A a,b;
}

对象对成员的访问

1.对象名.公有成员
2.指向对象的指针.成员 或 指向对象的指针->成员
3.对象的引用.成员
注意：类的外部不能之间访问私有成员，只能通过该类的公有函数来访问。

构造函数

声明格式：

类名：：构造函数名（与类名相同）（形式参数表）

特点：

1.一个类可以有多个构造函数，但是他们的形参个数和类型不能完全相同。
2.每当创建一个对象的时候，系统自动的去调用。
3.没有返回值类型。
4.不能被继承。
5.不能取地址。
6.可以重载
7.构造函数可以使用缺省参数。

利用构造函数创建对象

1.利用构造函数直接创建对象
格式：类名 对象名 （实参表）

class A
{
	……
};
A a(2010,8,9);

2. 通过指针和new来实现
   格式：类名 *指针变量=new 类名（实参表）

class A
{
	……
};
A *p=new A(2010,8,9);
//相当于 A *p;p=new A(2010,8,9);

带缺省值的构造函数

如果构造函数在类外定义，那么默认参数应该在类内声明构造函数时给定，而不是在类外定义时给定。

class A
{
	int x,y;
	A(int a=0,int b=0){x=a;y=b;}//带有缺省参数的构造函数
};

默认构造函数：

如果用户没有定义一个构造函数，系统将自动的提供一个构造函数。
注意：只要用户定义了一个构造函数，系统就不会提供构造函数

拷贝构造函数：

用一个已有的对象初始化一个被创建的同类对象。
特点：
1.是一种构造函数
2.形参是本类对象的引用
3.只有一个从参数
注意：
1.每一个类都必须有一个拷贝构造函数。
声明格式：类名（类名&对象名）

class A
{
	……
};
A::A(A&a)
{
	……
}

使用：

1.用类的一个对象去初始化另一个对象。

Stu s1;
Stu s2(s1);//创建s2时系统自动的调用拷贝构造函数，用s1的数据成员初始化s2

2.用类的一个对象去初始化另一个对象的另一种形式。

Stu s2=s1;

3.对象作为函数参数传递时，调用拷贝构造函数。

f(Stu a)
{}
Stu b;
f(b);//进行f函数调用时，系统自动调用拷贝构造函数。

4.如果函数的返回值是类的对象。，函数调用返回时，调用拷贝构造函数。

Stu f()
{
	Stu a;
	……
	return a;
}
Stu b;
b=f();

分类：

浅拷贝构造函数：

特点：只复制内存空间，不复制对象资源。
系统默认的是浅拷贝构造函数。

深拷贝构造函数：

特点： 既复制内存空间，又复制对象资源。
在以下两种情况必须会用到深拷贝：
1.肯定要调用拷贝构造函数
2.数据成员包括指向堆内存的指针变量（数据成员有使用new和delete以及对赋值=运算符进行重载）。

析构函数

特点：

1.在对象消亡时，释放对象占用的内存空间。
2.没有参数，没有返回值，每个类只能有一个析构函数。
3.在函数名前加~,函数名与类名相同。
4.可以系统调用也可以手工调用。手工调用格式：对象名.类名：：析构函数名

string类

运算符：+、=、+=、==、！=、<、>、<=、>=、[]、<<、>>

对象成员

类对象作为另一个类的数据成员

class A
{
};
class B
{
A a;  //A类的对象a作为B类的数据成员，先调用A的构造函数，再调用B的的构造函数
};

class X
{
	A a;//对象成员1
	B b;//对象成员2
	C c;//对象成员3
	……
};

类X的构造函数的定义形式：
X::X(形参总表):对象成员1（形参表1），对象成员2（形参表2），对象成员3（形参表3），……
注意：如果在类中包含对象成员，则在创建类的对象时先调用对象成员的构造函数，在调用类本省的构造函数。

对象数组：

定义：每一个数组元素都是对象的数组。
初始化：对对象成员的初始化，必须通过该类的构造函数来进行，通过初始化列表来进行。

Point a[2]={Point(1,2),Point(3,4)};

注意：数组元素的每一个元素都会调用一次构造函数和析构函数。

静态成员

静态数据成员

特点：

1.该类的所有对象都可以访问它，实现一个类不同对象之间的数据共享。
2.创建对象时不为静态数据成员分配内存空间。

class A
{
	static int x,y;
};
int A::x=5;//初始化在类外进行
int A::y=10;

初始化格式：数据类型 类名：：静态数据成员名=初始值
通过普通指针访问静态成员：

class A
{
	static int i;	
};
int A::i=0;//静态数据成员的初始化
void main()
{
	int *p=&A::i;//声明一个int 类型的指针，指向类的静态成员
	cout<<*p<<endl;//通过指针直接访问静态数据成员
}

静态成员函数

定义格式：

static 返回类型 静态成员函数名（参数表）

访问格式：

1.类名：：静态成员函数名（实参表）
2.对象.静态成员函数名（实参表）
3.对象指针->静态成员函数名（实参表）

特点：

1.静态成员函数无this指针，是所有同类对象共有的资源，不能直接访问非静态的数据成员，必须要通过某个该类的对象才能访问。
2.静态成员函数不能是虚函数。
3.可以还没有创建对象就调用。

常类型

常引用

说明形式：
1.const 类型&引用名=初值；
2.类型 const &引用名=初值；
注意：引用的对象不允许修改

常对象

说明形式：
1.const 类名对象名（参数表）；
2.const 类名 对象名（参数表）；
注意：
1.不允许改变常对象的数据成员。
2.不允许常对象调用普通成员函数。
3.常对象只能调用常成员函数。
3.在定义对象时必须进行初始化，而且不能被更新。

常成员

常数据成员：

只能通过初始化列表对该数据进行初始化，其他任何函数都不能对该成员赋值。

常成员函数：

格式：类型说明符 函数名（参数表）const;
注意：
1.只有常成员函数才能访问常对象
2.常成员函数可以访问常数据成员，普通数据成员，也可以访问常对象的数据成员，但是不能修改数据成员的值。
3.常成员函数不能调用该类的普通成员函数。

友元

友元的特点

1.只要将外界的某个对象（另一个类的成员函数，普通函数，另一个类）说明为一个类的友元，那么这个外界对象就可以访问这个类对象中的私有成员。
声明：friend

友元函数

特点：

1.没有this指针，访问该类的对象成员时，必须使用对象名。
2.在类中说明但不是该类的成员函数。
格式：friend 返回值类型 函数名 （参数表）
3.在类外定义时去掉friend。

class A//
{
	friend void f(A&);//说明该函数为友元函数
};
	void f(A&x)//在类外对友元函数进行定义
{
}

友元成员

class B;
class A
{
	void f(B&);
};
class B
{
	friend void a::f(B&);//A的成员函数f是B类的友元

};

友元类

class A
{
	……	
};
class B{
	friend class A;//A的所有成员函数都可以访问B类的所有成员
}

注意：
1.友元关系不能被继承
2.友元关系不具有传递性
3.友元关系是单向的，不具有交换性