面向对象编程（一）
一、面向对象编程介绍
（一）什么是面向对象？
面向将系统看成通过交互作用来完成特定功能的对象的集合。每个对象用自己的方法来管理数据。也就是说只有对象内部的代码能够操作对象内部的数据。
（二）面向对象的优点
·面向过程的缺点
不容易维护，灵活性差，不容易扩展，更谈不上复用，由于客户的需求多变，导致程序员加班加点，甚至整个项目经常返工。
·面向对象的优点
通过继承、封装、多态降低程序的耦合度，并结合设计模式让程序更容易修改和扩展，并且容易复用。
（三）面向对象的特点
抽象、封装、继承、多态
1.抽象：
·抽象是人们认识事物的一种方法
·抓住事物本质，而不是内部具体细节或者具体实现
2.封装
·封装是指按照信息屏蔽的原则，把对象的属性和操作结合一起，构成独立的对象。
·通过限制对属性和操作的访问权限，可以将属性“隐藏”在对象内部，对外提供一定的接口，在对象之外只能通过接口对对象进行操作。
·封装性增加了对象的独立性，从而保证数据的可靠性。
·外部对象不能直接对操作对象的属性，只能使用对象提供的服务。
3.继承
·继承表达了对对象的一般与特殊的关系。特殊类的对象具有一般类的全部属性和服务。
·当定义了一个类后，又需定义一个新类，这个新类与原来的类相比，只是增加或修改了部分属性和操作，这时可以用原来的类派生出新类，新类中只需描述自己所特有的属性和操作。
·继承性大大简化了对问题的描述，大大提高了程序的可重用性，从而提高了程序设计、修改、扩充的效率等。
4.多态
·多态性：同一个消息被不同对象接收时，产生不同结果，即实现同一接口，不同方法。
·一般类中定义的属性和服务，在特殊类中不改变其名字，但通过各自不同的实现后，可以具有不同的数据类型或者具有不同的行为。
当向图形对象发送消息进行绘图服务请求后，图形对象会自动判断自己的所属类然后执行相应的绘图服务。
总结：面向对象编程的优缺点
面向对象编程的优点：
·易维护：可读性高，即使改变需求，由于继承的存在，维护也只是在局部模块，维护起来是非常方便和较低成本的。
·质量高：可重用现有的，在以前的项目的领域中已被测试过的类使系统满足业务需求并具有较高质量。
·效率高：在软件开发时，根据设计的需要对现实世界的事物进行抽象，产生类。这样的方法解决问题，接近于日常生活和自然的思考方式，势必提高软件开发的效率和质量
·易扩展：由于继承、封装、多态的特性，自然设计出高内聚、低耦合的系统结构，使得系统更灵活、更容易扩展，而且成本较低。
面向对象编程的缺点：
运行效率会下降10%左右
二、类与对象
（一）类的声明
//类是一种用户自定义类型，声明形式：
class 类名称
{
public:
公有成员（外部接口）
private:
私有成员
protected：
保护成员
}；
例：
#include <iostream>
using namespace std;
class Test
{
public:
int x_;
protected:
int y_;
private:
int z_;
};
int main()
{
Test t;
t.x_ = 5;
t.y_ = 6; //Error!不可访问
t.z_ = 7; //Error1不可访问
cout << "t.x: " << t.x_ << endl;
return 0;
}
升级版：
#include <iostream>
using namespace std;
class Test
{
public:
int x_;
void setX(int x)
{
x_ = x;
}
void setY(int y)
{
y_ = y;
}
void setZ(int z)
{
z_ = z;
}
int getX()
{
return x_;
}
int getY()
{
return y_;
}
int getZ()
{
return z_;
}
protected:
int y_;
private:
int z_;
};
int main()
{
Test t;
t.x_ = 5;
cout << "t.x: " << t.x_ << endl;
cout << "t.y: " << t.getY() << endl;
cout << "t.z: " << t.getZ() << endl;
return 0;
}
编译结果：
PS:y,z未进行初始化所以是乱码。
（二）public、private、protected
·在关键字public后面声明，它们是类与外部的接口，外部函数都可以访问公有类型数据和函数。
·在关键词private后面声明，只允许本类中的函数访问，而类外部的任何函数都不能访问。
·在关键词protected后面声明，与private类似，其差别表现在继承与派生时对派生类的影响不同。
（三）成员函数
1.类内实现成员函数
函数类内实现默认为inline函数，占用空间，所有一般类外实现函数
上述例题中函数为类内实现
2.类外实现成员函数
例：
Test.h
#ifndef _TEST_H_
#define _TEST_H_
class Test
{
public:
int x_;
void initXYZ(int x, int y, int z);
void display();
protected:
int y_;
private:
int z_;
};
#endif
Test.c:
#include "Test.h"
#include <iostream>
using namespace std;
void Test::initXYZ(int x, int y, int z)
{
x_ = z;
y_ = y;
z_ = x;
}
void Test::display()
{
cout << "x:" << x_ << "\t" << "y:" << y_ << "\t" << "x:" << z_ << "\t" << endl;
}
lei.c:
#include <iostream>
#include "Test.h"
using namespace std;
int main()
{
Test t;
t.initXYZ(1, 2, 3);
t.display();
return 0;
}
运行结果：
3.成员函数的重载及默认参数
（四）class VS struct
class数据成员默认私有
struct数据成员默认公有
例：
#include <iostream>
using namespace std;
class Test
{
public:
int x_;
int y_;
int z_;
};
struct Test1
{
int x_;
int y_;
int z_;
void initXYZ(int x, int y, int z)
{
x_ = x;
y_ = y;
z_ = z;
}
};
int main()
{
Test t1;
t1.x_ = 5;
Test1 t2;
t2.initXYZ(1, 2, 3);
cout << "t1:" << t1.x_ << endl;
cout << "t2:" << t2.x_ << endl;
cout << sizeof(t1) << endl;
cout << sizeof(t2) << endl;
return 0;
}
运行结果：
C++编译器对struct升级：
在结构体内可以加入函数
由运行结果可知：
·类的大小与成员函数无关，只与成员有关
·对齐方式与大小与结构体一样
·对象的大小由成员决定
·方法是共享的
（五）对象的存储类型
代码验证：
#include <iostream>
using namespace std;
class Test
{
private:
int x_;
int y_;
int z_;
public:
void initXYZ(int x, int y, int z)
{
this->x_ = x;
this->y_ = y;
this->z_ = z;
}
};
int main()
{
Test *t1 = new Test();
t1->initXYZ(1, 2, 4);
return 0;
}
调试结果：
（六）类的作用域
前向声明:只能定义指针或者引用，不能有另一个类的对象
代码示例：
A.h
#ifndef _A_H_
#define _A_H_
class B;//前向声明
class A
{
public:
A();
~A();
private:
B *b; //B &b
};
#endif
B.h
#ifndef _B_H_
#define _B_H_
class B
{
public:
B();
~B();
};
#endif
A.cpp
#include "A.h"
#include <iostream>
using namespace std;
A::A()
{
cout << "init A!" << endl;
}
A::~A()
{
cout << "destory A!" << endl;
}
B.cpp
#include "B.h"
#include <iostream>
using namespace std;
B::B()
{
cout << "init B!" << endl;
}
B :: ~B()
{
cout << "destory B!" << endl;
}
main.c
#include <iostream>
#include "A.h"
#include "B.h"
int main()
{
return 0;
}
编译结果：
（七）嵌套类（内部类）
·从作用域的角度看，嵌套类被隐藏在外围类中，该类名只能在外围类中使用。如果
在外围类的作用域使用该类名时，需要加名字限定
·嵌套类中的成员函数可以在它的类体外定义
·嵌套类的成员函数对外围类的成员没有访问权，反之亦然。
·嵌套类仅仅只是语法上的嵌入
（八）局部类
·类也可以定义在函数体内，这样的类被称为局部类（local class）。局
部类只在定义它的局部域内可见
·局部类的成员函数必须被定义在类体中。
·局部类中不能有静态成员
代码示例：
#include <iostream>
using namespace std;
class Test
{
public:
int x_;
class Inner //嵌套类
{
public:
int num;
void func();
};
void setX(int x)
{
x_ = x;
display();
}
void setY(int y)
{
y_ = y;
display();
}
void setZ(int z)
{
z_ = z;
}
int getX()
{
return x_;
}
int getY()
{
return y_;
}
int getZ()
{
return z_;
}
protected:
int y_;
void display()
{
cout << x_ << y_ << z_ << endl;
}
private:
int z_;
};
void Test::Inner::func()
{
cout << "hello world" << endl;
}
int main()
{
class LocalClass //局部类
{
void func()
{
}
}
Test t;
Test::Inner n;
t.x_ = 6;
t.setY(6);
t.setZ(7);
cout << "t.y_ = " << t.getY() << endl;
cout << "t.z_ = " << t.getZ() << endl;
cout << "t.x_ = " << t.x_ << endl;
return 0;
}