网站开发建设哪家好网站404页面怎么做

类具有三大特性：封装、继承、多态

c++中万物皆可为对象，对象有属性和行为

例如：汽车可以看作对象，属性有：发动机、轮胎、方向盘等； 行为有：放歌、载人等

具有相同属性的也可以抽象为类

一、封装

1、语法： class 类名  {  访问权限：属性  行为  }；

行为是以函数形式出现

例如：设计一个学生类，包括姓名学号，可以赋值，也可以打印

#include<string>
using namespace std;class Student
{//设置访问权限// public 是公共权限
public:// 属性string name;long S_ID;// 行为// 打印姓名和学号void Print(){cout << "姓名：" << name << " 学号：" << S_ID << endl;}//也可通过行为对属性赋值void set_name(string N){name = N;}void set_ID(long ID){S_ID = ID;}};int main()
{// 创建具体的学生 （对象）也叫实例化对象Student S1;// 对实例化对象进行赋值S1.name = "李四";S1.S_ID = 2025001;S1.Print();// 创建第二个对象并通过行为赋值Student S2;S2.set_name("康康");S2.set_ID(2001007);S2.Print();return 0;
}

注意：

1、类中的属性和行为，统一称为 成员

2、属性又叫 ： 成员属性、成员变量

3、行为又名： 成员函数、成员方法

2、访问权限：

1、public:         公共权限   类内可以访问，类外也可以访问

2、protected： 保护权限   类内可以访问，类外不可访问 （子可以访问父的保护内容）

3、private:        私有权限   类内可以访问，类外不可访问   （only myself）

class Peo
{//公共权限// 人的名字
public:string name;// 保护权限，类内可访问// 大门密码
protected:long password;//私有权限，类内可访问// 资产
private:double money;//类内  均可访问
public:void fun(){name = "六六";password = 321123;money = 555555.55;}};int main()
{Peo P2;// 在类外 只能访问公共部分，保护和私有不能访问修改P2.name = "往往";return 0;}

3、struct 与 class 的不同

在c++中唯一区别：默认访问权限不同

struct 默认 公共权限

class  默认 私有权限

4、成员属性设置为私有 （private）

优点：

1、可以自己控制读写权限

2、对于写权限，我们可以检测数据的有效性

class Peo
{
public:// 写名字void set_name(string N){name = N;}//读名字string prit_name(){return name;}//读年纪int prit_age(){return age;}// 写最爱void set_love(string L){love = L;}// 写年龄，并且判断是否符合（0~150）void set_age(int A){// 判断是否符合if (A > 0 && A < 150)age = A;elsecout << "设置失败，年龄不合实际";}// 私有权限，类内可访问，类外不行
private:string name;  //可读可写int age=20; // 只读不写// ②、可写年龄，但是有范围string love; // 只写不读};int main()
{Peo p;// 直接访问 p1中的成员不行，private//读写姓名p.set_name("张三");cout<<p.prit_name()<<endl;// 设置年龄int A = 0;cin >> A;p.set_age(A);//读年龄cout<<p.prit_age()<<endl;//写最爱p.set_love("火锅");return 0;
}

利用，类内可以访问私有和保护的功能，可以完成，读写功能。

补充： 在类外设置类内私有成员，然后设置呢？

例题：

利用 ：：符号就可以达到这种效果

#include<iostream>
using namespace std;
// 定义长方形类
class oblong
{
private:int width;int length;//权限要是公共的
public://函数声明void set(int w, int l);int alcircle();int calarea();};//函数定义
// 赋值函数
void oblong::set(int w, int l)
{width = w;length = l;
}// 计算周长
int oblong::alcircle()
{return 2 * (width + length);
}//计算面积
int oblong::calarea()
{return width * length;
}int main()
{int w, l;cin >> w >> l;oblong ob;ob.set(w, l);cout << ob.alcircle() << endl<< ob.calarea() << endl;return 0;
}

补充：

::是C++里的作用域分解运算符，“比如声明了一个类A，类A里声明了一个成员函数voidf()，但没有在类的声明里给出f的定义，那么在类外定义f时，就要写成voidA::f()，表示这个f()函数是类A的成员函数，用这个函数时，通过这个类的变量去找到它。

【 ::  】的用法请转这位博主

---

---

二、对象的初始化和清理

1、构造函数和析构函数

这两个函数会被编译器自动调用，完成对象初始化和清理工作，如果我们不提供，编译器会自己提供，但是是空实现，内容为空。

构造函数：主要作用在于创建对象时为对象的成员赋值，有编译器自动调用；

析构函数：主要作用于对象销毁前系统自动调用，执行一些清理工作

构造函数语法： 类名（）{}

（1）没有返回值也不用写void

（2）函数名与类名相同，可以有参数，能发生重载

（3）程序调用对象时，自己调，无需手动，只会调用一次

析构函数语法： ~类名（）{}

（1）没有返回值，不写void ，加~，与类名相同

（2）不可以有参数，不能发生重载

（3）程序销毁前，自己调用，无需手动，只调一次

#include<iostream>
using namespace std;class stu
{public:stu(){cout << "stu 的构造函数" << endl;}~stu(){cout << "stu 的析构函数" << endl;}
};void test_1()
{stu p;
}int main()
{// 函数调用，用完释放test_1();// 主函数调用结束释放stu p;system("pause");return 0;
}

可以观察到，第二次的调用，结束后释放，才调用了析构函数。

2、构造函数的分类和调用

2种分类方式：
按参数分为：有参构造和无参构造
按类型分为：普通构造和拷贝构造

【拷贝构造语法： 类名（const 类名 & 变量）】
3种调用方式：
括号法
显示法
隐式转换法

#include<iostream>
using namespace std;class Person
{
public:// 普通构造函数 ：有参和无参Person(){cout << "Person的无参构造函数" << endl;}// 初始化列表  语法： 构造函数():属性1(值1),属性2(值2)…Person(int i):age(i){// 相当于 age=i;cout << "Person的有参构造函数" << endl;}// 拷贝构造函数Person(const Person& p){age = p.age;cout << "Person的拷贝构造函数" << endl;}// 析构函数~Person(){cout << "Person 的析构函数" << endl;}int age;};int main()
{// 1、括号法Person p1;Person p2(100);Person p3(p2);cout << "------------------" << endl;// 注意1：调用无参构造的时候，不要加() ，//编译器会认为是函数声明  Person p1()  ❌// 2、显示法Person pp = Person(100);Person pp1 = Person(pp);Person(10); // 匿名对象，执行这行后，立即释放cout << "---------------------" << endl;// 注意2： 不要用拷贝构造函数，初始化匿名对象// 编译器会认为： Person(pp1)==Person pp1  对象声明// 3、隐式转换法Person ppp = 10;  //相当于 Person ppp=Person(10)Person ppp1 = ppp;cout << "---------------------" << endl;return 0;
}

①、构造函数调用原则

1、创建一个 类 ，编译器就会给它分配添加至少3个函数：

默认构造（空实现）、析构函数（空实现）、拷贝构造（值拷贝）

2、若 我们写了 有参构造函数，编译器就不会给类提供默认构造函数啦,依然提供拷贝构造函数

3、若 我们写了 拷贝构造函数，编译器就不提供其  他普通构造函数

总结：（等级划分）拷贝>有参>默认

对于我们写的构造函数，编译器就不会提供更低级的，会提供更高级的

---

②、拷贝构造函数的调用时机

1、用已有对象初始化一个新对象

2、值传递的方式给函数参数传值

3、值的方式返回

值传递的 实质是 拷贝临时副本

#include<iostream>
using namespace std;class Stu
{
public:Stu(){cout << "Stu 默认构造函数" << endl;}Stu(const Stu& p){sore = p.sore;cout << "Stu 拷贝构造函数" << endl;}~Stu(){cout << "Stu 析构函数" << endl;}int sore;
};
// NO.2 值传递的方式给函数参数传值
void operate(Stu pp)
{cout << "NO.2 值传递-拷贝临时数据" << endl;
}void test_1()
{Stu p;operate(p);
}
// 3、值方式返回
Stu retu()
{Stu p1;return p1;// 返回时,按照p1 拷贝一个新的对象，返回给函数外
}void test_2()
{Stu p= retu();
}int main()
{test_1();cout << "------------" << endl;test_2();return 0;
}

---

③、深拷贝与浅拷贝

浅拷贝	简单赋值拷贝	编译器默认提供的
深拷贝	在堆区重新申请空间，进行拷贝	自己写的深拷贝操作

                      析构函数：可以 释放在堆区开辟的空间（delete）

#include<iostream>
using namespace std;class peo
{
public:peo(){cout << "peo 的默认构造函数" << endl;}peo(int a, int h){age = a;hight = new int(h);cout << "peo 的有参构造函数" << endl;}~peo(){// 释放身高指针指向的堆区空间if (hight != NULL){delete hight;hight = NULL;}cout << "peo 的析构函数" << endl;}// 如果我们没有这一步操作，编译器会提供一个拷贝构造函数// 实现 hight=p.hight 进行的是地址传递，运行时会发生错误peo(const peo& p){// 深拷贝，在堆区开辟空间，进行拷贝age = p.age;hight = new int(*p.hight);cout << "peo 的深拷贝" << endl;}int age;int* hight; // 身高指针，接收在堆区开辟的地址};int main()
{peo p1(10, 175);peo p2(p1);cout << "p1的年龄和身高：" << p1.age << " " << *p1.hight << endl;cout << "p2的年龄和身高：" << p2.age << " " << *p2.hight << endl;return 0;
}

如若我们没有自己定义拷贝函数进行深拷贝，编译器会给我们提供一个拷贝函数，进行浅拷贝

（hight=p.hight）,会发生如下错误 👇：

如果我们写了可以进行深拷贝的拷贝构造函数，就可以避免↑上面情况的发生

---

---

④、类对象作为类成员

class A{}；

Class B

{

A member；

}；

B类中有A来作为成员，它俩创建的顺序是怎么样的呢？

先有A，再有B；释放的时候 先释放 B，后释放A

#include<iostream>
#include<string>
using namespace std;class cloth
{
public:cloth(string p){c_name = p;cout << "cloth 的构造函数" << endl;}~cloth(){cout << "cloth 的析构函数" << endl;}string c_name;
};class Person
{
public:// cl(b) 相当于 cloth cl=b;隐式转换法Person(int a, string b) :age(a), cl(b){cout << "Person 的构造函数……" << endl;}~Person(){cout << "Person 的析构函数……" << endl;}int age;cloth cl;
};int main()
{Person p1(24, "亮晶晶");cout << "年龄：" << p1.age << " 衣服品牌：" << p1.cl.c_name << endl;}

结果如下：

【当其他类对象作为本类成员，构造时先构造类对象，再构造本类】

  析构时 与之相反   👇👇

⑤、静态成员

静态成员 就是 在成员前面+static

静态成员也都有访问权限，在public 的属性下，才能随意的调用，private下面不行了。

一、静态成员变量：

1、所有对象都共享同一份数据

2、编译阶段就分配内存

3、类内声明，类外初始化

注意： 静态成员变量  不属于某个对象上，所有对象都共享同一份数据

静态成员变量有2种访问方式：

1、通过对象

2、通过类名

#include<iostream>
using namespace std;class home
{
public:// 类内声明，类外初始化static int people;
};
// 类外 初始化
int home::people = 4;// 静态成员变量的两种访问方法
void test_001()
{// 一、通过对象home t1;t1.people = 2;cout << "通过对象：" << t1.people << endl;// 二、通过类名cout << "通过类名 ：" << home::people << endl;}int main()
{home h1;cout << "h1 家庭成员个数为：" << h1.people << endl;home h2;h2.people = 6;cout << "h2 家庭成员个数为：" << h1.people << endl;home h3;cout << "h3 家庭成员个数为：" << h1.people << endl;test_001();return 0;
}

结果： 👇 👇

二、静态成员函数

1、所有对象共享一个函数

2、静态成员函数只能访问静态成员变量

因为无法区分是哪个对象的非静态成员变量，静态成员变量是大家共有的，所以都可以访问

     静态成员函数调用方法与👆一样

class AAA
{
public://静态成员函数static void fun(){// 可以调用 静态成员变量A = 100;// 不可以调用 非静态成员变量// 因为不知道，这个B是对象p1的B呀，还是对象p2的B呀// 人家A 是大家共有的，都可以使用，你B可是一人一个，个人财产//B = 100; 错误}// 静态成员变量static int A;// 非静态成员变量int B;};// 静态成员变量，类外声明
int AAA::A = 10;

---

第一弹 就此先结束啦！！！！