一.面向对象
什么是对象?
你能看到的万事万物,都是对象,比方说桌子,电脑,水杯…..。”万物皆对象。”
什么是面向对象?
面向对象简称 OO(Object Oriented),一种编程思想。面向对象编程,简称OOP(Object Oriented Programming)。抽象出思维,不再是线性的思维方式。
举例:大象装冰箱。 线性的思维:打开冰箱门,装进大象,关上冰箱门。一系列的动作,有先后,顺序发生的。 面向对象对象思维: 抽象出3个类,1个类大象 ,搞清楚大象有哪些静态特征,哪些动态的行为(进入冰箱),1个类 冰箱 ,分清有哪些静态特征,哪些动态行为(开门,关门), 操作类(测试类),组合大象,和冰箱,实现功能。
面向对象和面向过程有什么区别?
面向对象:盖浇饭 ,盖菜和饭分离,菜饭分离---à不喜欢盖菜,可以剥掉,重新加。面向对象通过3大特征,提供大范围大面积的解决思路。
面向过程:蛋炒饭 ,米饭盒鸡蛋混合在一起,--à不喜欢鸡蛋,只能倒掉,重新做。面向过程提供小面积的解决思路
面向对象:纪传体(各个人物分散,比方说史记),面向过程:编年体(按时间先后 ,资治通鉴)
二.面向对象特点
封装,继承,多态,抽象
三.类的封装
类的访问控制:
在C++中可以给成员变量和成员函数定义访问级别
public修饰成员变量和成员函数可以在类的内部和类的外部被访问
private修饰成员变量和成员函数只能在类的内部被访问
没有权限修饰的成员和函数默认是private的
封装:
A)封装,是面向对象程序设计最基本的特性。把数据(属性)和函数(操作)合成一个整体,这在计算机世界中是用类与对象实现的。
B)封装,把客观事物封装成抽象的类,并且类可以把自己的数据和方法只让可信的类或者对象操作,对不可信的进行信息隐藏。
备注:有2层含义(把属性和方法进行封装 对属性和方法进行访问控制)
C++中类的封装:
成员变量,C++中用于表示类属性的变量
成员函数,C++中用于表示类行为的函数
#include <iostream>
using namespace std;
// 求圆的面积
struct circle
{
double m_r; // 圆的半径
double m_s; // 圆的面积
};
// C++中提供一个新的关键字 class, 用来定义类,使用方式和struct基本相同
// 但是增加一些其他的特性
// 类的封装:1、封装属性 2、封装方法
// 类的内部、类的外部
// 类的访问控制关键字:对属性和方法的使用权限进行限制
// public : 可以在类的内部和类的外部访问
// private : 可以在类的内部但不能在类的外部访问
// protect :可以在类的内部访问,但不能在类的外部访问,用在继承里面
class Circle
{
public: // 类的成员访问权限,public 表示公开权限
double m_r; // 圆的半径,类的内部成员, 也叫属性
double m_s; // 圆的面积
public: // 类中不仅可以又成员变量,还可以有成员函数,用来定义类的一些操作方法
// 类的成员函数,设置类的半径
void setR(double r)
{
m_r = r;
}
// 获取圆的半径
double getR()
{
return m_r;
}
// 获取圆的面积
double getS()
{
m_s = 3.14 * m_r * m_r;
return m_s;
}
};
void printCircle1(Circle c)
{
cout << c.getS() << endl;
}
void printCircle2(Circle& c)
{
cout << c.getS() << endl;
}
void printCircle3(Circle* c)
{
cout << c->getS() << endl;
}
int main()
{
Circle c1,c2; // 用类来定义变量 我们一般将这个变量叫对象
// 类的成员使用方式和结构体一样,对象使用 . 引用成员, 对象指针使用 -> 引用成员
c1.setR(10); // 设置 对象 c1 的半径
// 打印圆的半径
cout << c1.m_r << endl;
// 调用成员函数获取圆的面积
cout << c1.getS() << endl;
printCircle1(c1);
printCircle2(c1);
printCircle3(&c1);
return 0;
}
struct和class的区别:
//struct demo //class demo // 无法访问 private 成员(在“demo”类中声明)
//{
// char ch;
// int a;
//
// void fun()
// {
// cout << "ch = " << ch << ", a = " << a << endl;
// }
//};
// 结构体成员属性默认是公有的,类成员属性默认是私有的(private),在外部不可以被访问,只能在内部访问
//类成员属性改成公有的 public 类内部外部都可以访问
// protect: 保护属性,用在继承中,也只能在类的内部访问
class demo
{
public:
char ch;
int a;
void fun()
{
cout << "ch = " << ch << ", a = " << a << endl;
}
};
int main()
{
demo d;
demo *p;
d.ch = 'a';
d.a = 10;
d.fun();
p = &d;
p->ch = 'b';
p->a = 20;
p->fun();
/*ch = a, a = 10
ch = b, a = 20*/
return 0;
}
四.对象的构造与析构
创建一个对象时,常常需要作某些初始化的工作,例如对数据成员赋初值。注意,类的数据成员是不能在声明类时初始化的。
为了解决这个问题,C++编译器提供了构造函数(constructor)来处理对象的初始化。构造函数是一种特殊的成员函数,与其他成员函数不同,不需要用户来调用它,而是在建立对象时自动执行。
构造函数:
1)C++中的类可以定义与类名相同的特殊成员函数,这种与类名相同的成员函数叫做构造函数;
2)构造函数在定义时可以有参数;
3)没有任何返回类型的声明。
可以自动调用也可以手动调用。
析构函数:
1)C++中的类可以定义一个特殊的成员函数清理对象,这个特殊的成员函数叫做析构函数
语法:~ClassName()
2)析构函数没有参数也没有任何返回类型的声明
3)析构函数在对象销毁时自动被调用
编译器自动调用。
#include <iostream>
class Test
{
public:
Test() // 构造函数,构造函数与类名相同,没有返回值
{
std::cout << "我是构造函数,被调用了" << std::endl;
}
~Test() // 析构函数,析构函数与类名相同,前面有个~ 不能有返回值和参数
{
std::cout << "我是析构函数,被调用了" << std::endl;
}
};
int main()
{
// 类在创建对象的时候会自动调用构造函数
Test t1;
std::cout << "hello world" << std::endl;
Test *t2 = new Test();
std::cout << "1" << std::endl;
delete t2; // 对象在被销毁的时候会自动调用析构函数
std::cout << "2" << std::endl;
{
Test t3;
}
std::cout << "3" << std::endl;
return 0;
}
五.对象的构造与析构
class Text2_2
{
public:
Text2_2()
{
m_a = 3;
m_b = 4;
//printf("m_a = %d,m_b = %d\n",m_a ,m_b);
printf("无参构造函数被调用\n");
}
Text2_2(int a)
{
m_a = a;
printf("m_a = %d\n",m_a);
printf("一个参数构造函被调用\n");
}
Text2_2(int a,int b)
{
m_a = a;
m_b = b;
//printf("m_a = %d,m_b = %d\n",m_a ,m_b);
拷贝构造:
#include <stdio.h>
class Text5_1
{
public:
Text5_1(int a)
{
m_a = a;
printf("普通构造函数\n");
}
Text5_1(const Text5_1 &obj)
{
m_a = 100;
printf("拷贝构造被调用\n");
}
~Text5_1()
{
printf("***********析构函数被调用: m_a = %d\n", m_a);
}
void print()
{
printf("m_a = %d\n",m_a);
}
private:
int m_a;
};
void text (Text5_1 t)
{
t.print();
}
int main()
{
//调用拷贝构造的情况
//1,直接初始化
Text5_1 t1(10); //m_a = 10
Text5_1 t2 = t1; //用t1初始化t2
//调用一次拷贝构造函数 m_a = 100,两次析构函数
//2,等于号
Text5_1 t3 = t1; //m_a = 10
t3.print(); //m_a = 100
//3,对象作为函数参数
text(t1);// 调用一次拷贝构造
return 0;
}
默认拷贝构造:
1)默认无参构造函数
当类中没有定义构造函数时,编译器默认提供一个无参构造函数,并且其函数体为空
2)默认拷贝构造函数
当类中没有定义拷贝构造函数时,编译器默认提供一个默认拷贝构造函数,简单的进行成员变量的值复制
构造析构阶段性总结 :
1)构造函数是C++中用于初始化对象状态的特殊函数
2)构造函数在对象创建时自动被调用
3)构造函数和普通成员函数都遵循重载规则
4)拷贝构造函数是对象正确初始化的重要保证
5)必要的时候,必须手工编写拷贝构造函数