- 1、面向过程和面向对象
- （1）面向过程编程（C语言）
- （2）面向对象编程（Java、C++）
- 2、面向对象的四（三）大特征
- （1）抽象
- （2）封装
- （2）继承
- （3）多态
- 3、类
- 4、对象
- 5、构造函数
- 特点：
- 6、析构函数
- 特点：
- 7、拷贝构造函数
- 作用：
- 何时会调用拷贝构造函数？
- 深拷贝和浅拷贝：
- 注意：
- 8、赋值函数
- 9、this指针
- 10、静态数据static
- 11、const数据
- **特点：**
- 12、友元函数
- 13、友元类
- 14、智能指针
分析出解决问题的步骤，再用函数将这些步骤一一实现，使用的时候依次调用，面向过程的核心是过程。
优点：性能比面向对象好，因为类调用时需要实例化，开销比较大，比较消耗资源。比如单片机、嵌入式开发、 Linux/Unix等一般采用面向过程开发，性能是最重要的因素。
缺点： 缺点：不易维护、不易复用、不易扩展。
（2）面向对象编程（Java、C++）把构成问题的事物分解成一个个对象，建立对象不是为了实现某一个步骤，而是为了描述某个事物在解决问题中的行为，面向对象的核心是对象。
优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护。
缺点：性能比面向过程低。
举例：人吃饭
面向过程：强调的是吃饭的这个过程，人只是一个参数。
面向对象：强调的是人，吃饭只一个其中一个的动作。
2、面向对象的四（三）大特征 （1）抽象将具体的问题（对象）进行概括，抽出这类对象的共同特征（静态、动态），叫做抽象。举例：人类这个概念就是抽象出来的。动态：说话，吃饭，思考，静态：头，手，足等。
（2）封装将抽象出来的共同特征（静态、动态）包装在一起成为一个整体，把数据（变量）和操作数据的方法（函数）封装在一起，对自己信任的对象提供操作，对不信任的对象隐藏。封装的实现：类class。
（2）继承是指让某个类型的对象获取另一个类型的对象的属性的方法。
（3）多态是指向不同的对象发送同一个消息，会产生不同的行为。
3、类类是具有相同属性和行为的一组对象的集合，它为属于该类的对象提供统一的抽象描述，其内部包含了属性（静态特征）和行为（动态特征）。
类的声明：
class 类名（首字母一般是大写）
{
public： //公有成员，是对外部的接口
private: //私有成员
protected： //保护成员
}; //分号不要忘记
公有成员：用关键字public修饰，它是类与外部的接口，类外可以访问公有成员，必须通过对象。
私有成员：用关键字private修饰，只允许类中成员访问，而类外不能直接访问私有成员。
保护成员：用关键字protected修饰，特点跟私有成员一致，在继承时对派生类的影响不同。
注意：一个类中不是必须要包含三种成员
class A 注意与struct的区别
{
int a; //默认是私有成员
}
//钟表类
class Clock
{
public:
void set_time(); //成员函数
void get_time();
private:
int hour; //成员数据
int minute;
int second;
protected:
};
成员数据：跟普通变量没有区别，只是声明在类中
成员函数：在类中声明的函数，在哪个地方实现呢？
（1）在类中实现，自动形成内联函数
class Clock
{
public:
//在类中实现的函数，会自动形成内联函数
void set_time(int h=0,int m=0,int s=0) //成员函数
{
hour = h;
minute = m;
second = s;
}
void get_time();
private:
int hour; //成员数据
int minute;
int second;
protected:
private:
};
（2）在类外实现，实现时要用“类名::”指定是属于哪个类的函数
void Clock::get_time()
{
cout << hour << ":" << minute << ":" << second << endl;
}
4、对象
对象是一个类的示例，即类的变量
声明形式：
类名 对象名
如：
Clock myclock;
Clock *myclock = new Clock;
成员函数的访问方式：
类中成员互访：直接使用成员名
类外访问成员：
使用“对象名.成员名” 或 “对象名->成员名”
只能直接访问公有成员
Clock myclock1; myclock1.set_time(12,30,00); myclock1.get_time(); Clock *myclock2 = new Clock; myclock2->set_time(12,30,00); myclock2->get_time(); delete myclock2; myclock2 = NULL;5、构造函数
作用：在创建对象时，对成员数据进行初始化
声明形式：
类名(参数列表)
{
}
如：
Clock(int h=0,int m=0,int s=0) //构造函数
{
hour = h;
minute = m;
second = s;
}
特点：
（1）在创建对象时，由系统自动调用
（2）如果没有声明构造函数，那么系统会生成一个默认的构造函数（没有作用）
（3）构造函数可以声明为内联函数，重载函数，带默认参数的函数
（4）构造函数可以有参数，但是不能写返回类型
（5）构造函数不能为虚函数，可以类内声明，类外构造
//构造函数
Clock(int h=0,int m=0,int s=0)
{
cout << "构造函数n";
hour = h;
minute = m;
second = s;
}
//Clock myclock1(); //不传参数时，加括号和不加括号是有区别
Clock myclock1;
myclock1.get_time();
Clock *myclock2 = new Clock(); //不传参数时，加括号和不加括号是没有区别
myclock2->get_time();
delete myclock2;
myclock2 = NULL;
6、析构函数
作用：在对象删除时，进行清理工作
声明形式：
~类名()
{
}
特点：
（1）在删除对象时，由系统自动调用
（2）如果没有声明析构函数，那么系统会生成一个默认的析构函数（没有作用）
（3）一个类中有且仅有一个析构函数
（4）析构函数不写参数和返回类型
（5）析构函数可以为虚函数，且某些情况下，必须为虚函数
7、拷贝构造函数 作用：拷贝构造函数是一种特殊的构造函数，其形参为类对象的引用，如果没有声明拷贝构造函数，那么系统会生成一个默认的拷贝构造函数（有作用）
声明：
类名(const 类名 &对象名);
如：
Clock(const Clock &myclock):t(t)//若t被const修饰则使用：（）初始化参数
{
}
何时会调用拷贝构造函数？
①用一个对象去初始化另一个对象时，会自动调用拷贝构造函数
Clock myclock2(myclock1); //拷贝构造函数，复制 myclock2.get_time(); Clock myclock3 = myclock1; //拷贝构造函数，复制 myclock3.get_time(); Clock myclock4; myclock4 = myclock1; //赋值函数，赋值 myclock4.get_time();
②如果函数的参数是类对象时，调用该函数，会自动调用拷贝构造函数
③如果函数的返回值是类对象时，调用该函数，会自动调用拷贝构造函数
void fun1(Clock myclock) //参数是类对象
{
}
调用：fun1(myclock1); //调用拷贝构造函数
void fun11(Clock &myclock) //参数是类对象的引用
{
}
调用：fun11(myclock1); //不会调用拷贝构造函数
④如果函数的参数是类对象的引用时，调用该函数，会自动调用拷贝构造函数吗？不会
⑤如果函数的返回值是类对象的引用时，调用该函数，会自动调用拷贝构造函数吗？不会
Clock fun2(void) //返回值是类对象
{
Clock myclock1;
return myclock1;
}
myclock4 = fun2(); //调用拷贝构造函数
Clock & fun22(void) //返回值是类对象的引用
{
static Clock myclock1;
return myclock1;
}
myclock4 = fun22(); //不会调用拷贝构造函数
深拷贝和浅拷贝：
浅拷贝：默认的拷贝构造函数都是浅拷贝，只是对值进行了拷贝
深拷贝：如果在类中，在堆上申请了空间，那么必须重写拷贝构造函数，实现空间的拷贝。
注意：一般情况下，浅拷贝不需要重写拷贝构造函数，使用默认的拷贝构造函数即可，但是在堆上申请了空间，就必须进行深拷贝，除了值的拷贝，要重新申请空间。
class Clock
{
public:
//构造函数
Clock(int h=0,int m=0,int s=0)
{
cout << "构造函数n";
hour = h;
minute = m;
second = s;
p = new int(5);
}
//析构函数
~Clock()
{
cout << "析构函数n";
delete p;
p = NULL;
}
//拷贝构造函数(深拷贝)---------------------------------------------------------
Clock(const Clock &myclock)
{
cout << "拷贝构造函数n";
hour = myclock.hour;
minute = myclock.minute;
second = myclock.second;
p = new int;
*p = *myclock.p;
}
void get_time();
private:
int hour; //成员数据
int minute;
int second;
protected:
int *p;
};
8、赋值函数
声明形式：
类名 & operator=(const 类名 &对象名);
如：
Clock & operator=(const Clock &myclock)
如果没有声明赋值函数，那么系统会生成一个默认的赋值函数（有作用）
9、this指针作用：用于指向本类对象，只有非静态的成员函数才有this指针，这个指针是成员函数中隐藏的参数
如：
Clock(this,int h,int m,int s) //this是隐藏的，不需要写出来
{
}
this的使用情况：
（1）函数的参数和成员数据同名时
Clock(int hour=0,int minute=0,int second=0) //成员函数
{
this->hour = hour;
this->minute = minute;
this->second = second;
}
（2）函数的返回值为类对象时，可以使用this指针
Clock fun()
{
Clock myclock;
return *this;
}
10、静态数据static
静态成员数据：
在成员数据前加上static关键字
特点：
（1）静态成员数据必须在类外初始化，通过“类名::”限定属于哪个类
（2）该类的所有对象维护该成员的同一个拷贝，类似于C中static修饰局部变量，只会被初始化一次。
静态成员函数：
在成员函数前加上static关键字
特点：
（1）在类外，普通成员函数只能通过“对象名+函数名”进行访问；而静态成员函数既可以通过“对象名+函数名”进行访问，又可以通过“类名::函数名”进行访问。
（2）静态成员函数只能访问静态成员
（3）静态成员函数没有this指针
11、const数据常量：const int a;
常指针：const int *p;
常数组：const int arr[5];
常引用：const int &b = a;
常对象：const Clock myclock(10,10,10) ; // 常对象必须初始化
常成员数据：在成员数据前用const修饰，如：const int a;
常成员函数：在成员函数后用const修饰，如：void fun() const;
特点：（1）常成员数据在构造函数的参数列表初始化，普通数据数据也可以
如：Clock(int h=0,int m=0,int s=0):a(10),b(20)
（2）常成员函数不能修改任何变量的值，既可以访问普通数据，也可以访问const数据
（3）常对象必须初始化
（4）常对象只能调用常成员
12、友元函数声明方式：在函数前加上“friend”关键字修饰，如：friend void fun();
注意：在类中声明，但不是成员函数
作用：友元函数可以访问类的私有成员和保护成员，但必须通过类对象，破坏了封装性，但增强了灵活性，让程序员在封装性和快速性方面进行合理的选择。
class A
{
public:
friend void display(A a); //声明为A的友元函数
A(int a = 0)
{
this->a = a;
}
~A()
{
}
private:
int a;
};
void display(A a)
{
cout << a.a << endl;
}
eg：计算两个点之间的距离
Point p1(1,2),p2(2,4);
Distance();
class Point
{
public:
//friend void display(A a); //声明为A的友元函数
Point(int x = 0,int y = 0)
{
this->x = x;
this->y = y;
}
~Point()
{
}
friend float Distance(Point &p1,Point &p2);
private:
int x,y;
};
float Distance(Point &p1,Point &p2)
{
return sqrt(pow((p1.x-p2.x),2)+pow((p1.y-p2.y),2));
}
int main(void)
{
Point p1(1,2),p2(2,4);
cout << "距离为：" << Distance(p1,p2) << endl;
}
13、友元类
若一个类是另一个类的友元类，那么该类的所有成员函数都是另一个类的友元函数。
如：A是B的友元类，A的所有成员函数都是B的友元函数
声明：
class A
{
friend class B; //声明B是A的友元类
};
设置为互为友元类：
class B; //前向引用声明
class A
{
friend class B; //声明B是A的友元类
void fun(B b); //要访问B的私有和保护成员，就必须传B的对象
};
class B
{
friend class A; //声明A是B的友元类
void fun(A a); //要访问A的私有和保护成员，就必须传A的对象
};
说明：
（1）友元类是单向的
（2）友元类不具有传递性，如A是B的友元类，B是C的友元类，A不一定是C的友元类
（3）友元类不能继承，如B是A的儿子，C是B的友元类，C不一定A的友元类
14、智能指针背景：如果使用普通指针，当用new在堆上申请空间之后，就必须调用delete去释放空间，否则会造成内存泄漏（一个资深的程序员是不会犯这种低级错误的），麻烦的是不知道在哪里去释放空间，因为这片内存可能会在多处被使用（多线程）。
如果使用智能指针，那么就不用调用delete，空间使用完毕之后，会自动释放空间。
C++中智能指针：auto_ptr（被弃用），unique_ptr，shared_ptr，weak_ptr
#include#include #include //智能指针 using namespace std; class A { public: friend void display(A a); //声明为A的友元函数 A(int a = 0) { this->a = a; } ~A() { cout << "析构函数n"; } void show() { cout << "a = " << a << endl; } private: int a; }; int main(void) { A *a1 = new A(10); //普通指针，必须调用delete释放空间 a1->show(); shared_ptr a2(new A(20)); //智能指针，不需要调用delete释放空间 a2->show(); delete a1; a1 = NULL; }
参考：
智能指针
暑期编程PK赛 得CSDN机械键盘等精美礼品！
