达内--C++(day11)

C++笔记 2007年04月05日
1、本对象子类对象其他函数
private属性可见不可见不可见
protected属性可见可见不可见
public属性可见可见可见
public extends protected extends private extends
父类的private属性不能访问不能访问不能访问
父类的protected属性变成protected 不变变成private，子类可以访问，子
类的子类不能访问
父类的public属性不变变成protected 变成private，子类可以访问，子
类的子类不能访问
2、构造函数有很多种，因为没有指定构造函数，就会默认使用无参的构造函数。

如果父类没有无参的构造函数，那么就会出现编译错误。

可以使用这种形式Teacher(char* name, int age, double salary):Person(name,age){......}，指定使用父类的有参构造函数。

3、多态的特征：
父类的指针可以指向子类的对象
通过父类指针只能调用父类中声明的方法
通过指针调用函数的时候，若函数是个虚函数，表现出来的行为是对象自身的行为
4、产生多态：（1）指针
（2）引用
父类的引用可以引用一个子类对象
通过父类引用只能调用父类函数
调用一个父类被覆盖了的，虚函数，能调用子类的函数
5、一个子类继承一个父类 --- 单继承
一个子类继承多个父类 --- 多继承
class SpiderMan : public Spider , public Person{....}
6、菱形继承，解决重复元素的冲突
让两个父类同时虚继承一个超类，把多继承中的重复元素放在超父类中
当有多个子类同时虚继承一个父类的时候，只有一个子类真正的构造父类
class Spider : vertual public Animal{.....};
class Person : vertual public Animal{.....};
class SpiderMan :public Person , public Spider{....};
多继承尽量不要使用三层以上
7、抽象类
只有函数声明，没有函数实现
纯虚函数：没有实现的函数 virtual void writeLog(char*)=0;
若不写" =0 "，则系统会认为是函数声明，会试图去别的" .cc "文件中去找函数实现含有纯虚函数的类称为抽象类，是抽象数据类型，不能创建对象
抽象类型就是为了被别人继承的，子类覆盖纯虚函数，提供函数实现
通过父类规范子类的用法
如果子类没有完全实现抽象父类的所有纯虚函数，则认为子类还是一个抽象数据类型
用到virtual的地方：
（1）继承
（2）多继承
（3）纯虚函数
抽象类的规范很重要，在工程中，对于项目的并行开发很重要
而且对于项目中的改动，能方便的应付
用指针指向相应的子类对象，方便的调用子类的函数
8、友员
针对类来说，自身的私有变量，不能被别的类访问，但是，如果授权给一个类为自己的友员，就可以访问他的私有属性
可以作为友员的东西：另一个类，一个全局函数。

实现友员的授权：
class Girl;
class Person{
........
friend class Girl; //友员类的声明-->授权给Girl类，成为自己的友员，可以访问自己的私有
变量了
}
----------------------------------------------------------------------------------------------------------------
class Girl;
class Person{
........
friend void fn(); //友员函数的声明-->授权给fn函数，成为自己的友员，可以访问自己的私有
变量了
}
友员不是类的一部分
若不是互为友员，则不能访问友员类的私有变量
友员的使用：
Bus把售票员作为自己的友员，访问自己的私有变量，即装载乘客的数组
友员在项目中的使用
9、静态数据
在类中定义一个静态数据（实际上就是一种全局变量）
（1）不依赖于对象,在对象不存在之前就已经存在了
（2）所有对象共享
与全局变量的区别：
（1）使用的类中的静态变量，必须通过类名使用
（2）而且受访问控制符号的限制
（3）静态变量在类中声明的时候不能赋值，要在类外初始化
class A{
public :
static int a;
};
int A::a = 100; //此时才分配空间
int main(){
cout << A::a <<endl; //静态变量的用法，不依赖对象，直接使用 }
与成员变量的区别
（1）成员变量依赖与对象，类对象不存在，成员变量也不存在
静态变量不依赖于对象，只要有类声明，就存在
（2）所有对象共享一份静态变量
10、静态函数
在函数前加static
不依赖于对象，没有对象依然可以通过类名调用静态函数
A::fn();
在类声明的时候，静态函数和静态变量就存在了
静态函数只能使用静态变量，不能使用成员变量
11、拷贝构造函数
#include <iostream>
using namespace std;
class Person{
public:
Person(){ cout<<"Person()"<<endl; }
~Person(){ cout<<"~Person() "<<endl;}
void speak(){ cout<<"hello"<<endl; }
};
void fn( Person p ){ //这里的传递时值传递，形参是值传递，这里的形参的创建是使用拷贝构造函数 p.speak();
}
int main(){
Person p ;
fn( p ) ;
return 0 ;
}
输出结果：
Person()
hello
~Person()
~Person() //2次析构，因为其中调用了的系统提供的拷贝构造函数，构造出一个新对象
拷贝构造函数，以一个已存在的对象为模版创建一个新对象
声明方法： Person(const Person & p){...} //即节省空间，又保证模版不会被修改
默认拷贝构造函数，执行的就是简单的内存拷贝 --- 浅拷贝
（1）浅拷贝
只拷贝地址，而不是对指针指向空间的拷贝，会造成2个指针指向同一个空间（2）深拷贝
为指针创建新空间，拷贝指针指向空间的内容
调用拷贝构造函数的时机：
（1）在值传递的时候
（2）A a; //默认构造函数
A a1 = a; //在声明的时候，用一个对象赋值，使用的是拷贝构造函数
（3）A a1;
A a2(a1); //显示的调用拷贝构造函数，传的参数是个对象
什么时候需要自己写拷贝构造函数？
使用了动态内存，就会面临浅拷贝的现象，需要自己写拷贝构造函数
12、运算符重载
a1 = a2;
系统调用了函数 operator=
相当于执行了这样的操作： a1.operator=(a2);
Student& operator= (const Student &a);
函数返回左值，返回值为引用
函数返回右值，返回值为本身
/*
*student a1;
*student a2;
*a1=a2; <=> a1.operator=(a2);
*/
Student& operator= (const Student &a){
age = a.age;
id = a.id;
strcpy(name , ); //不用new出一块空间，因为在声明a1和a2的时候，两个指针都指向一块自己的空间，
把指针指向的变量拷贝过去，即完成赋值
return *this;
}
当在堆中申请空间，则覆盖赋值运算符（" = "）
作业：银行系统的账户类
把name , password 改用指针保存
（1）析构函数
（2）拷贝构造
（3）重载赋值运算符。