C++类和对象小结

学习目标：

提示：这里可以添加学习目标

掌握C++类的使用

---

学习内容：

1.什么是类
C中结构体的增强版，可以有成员函数，可以重载，C中结构体可看作所有数据成员访问权限都为public的类；
2.类的定义
用关键字class开头；

class A{
	int a;//private
	public:
		char b;
	protected:
		double c;
	private:
		char d;
}

3.定义类的对象
类似C，

A cl_1;
A cl_2;

4.访问访问权限为public的数据成员

#include<iostream>

class square{
	public: 
    int length,width;
};
using namespace std;
int main()
{
	square square_1;
	square_1.length =3;
	square_1.width = 2;
    int c =square_1.length*square_1.width;
	cout<< c <<endl;
	return 0;
}

5.类的成员函数

class square{
	public: 
    int length,width;
    int s()
    {
    	return length*width;
    }
};
//or
//class square{
//	public: 
 //   int length,width;
  //  int s();
//};
//inline int square::s(){//::作用域符号
//    return length*width;
//    }
int main()
{
	square square_1;
	square_1.length =3;
	square_1.width = 2;
    //int c =square_1.length*square_1.width;
	cout<< square_1.s() <<endl;
	return 0;
}

6.类的访问修饰符
public,
public的成员是在类的外部仍可进行访问的，在类的外部可以不使用任何成员函数来给成员赋值。
private的成员变量或函数在类的外面是无法访问的，甚至无法查看，只有类和友元可以访问私有成员。
protected的成员变量和函数与private的成员类似，但protected的成员在派生类/子类中是可以访问的
如果类中的成员没有声明访问权限，默认权限是private的。
继承中的特点

7.构造函数和析构函数
构造函数：类的构造函数是类的一种特殊的函数，这个函数会在每次创建类的新对象时进行调用，构造函数的名称和类是完全相同的，并且函数在调用的时候不会返回任何类型，也不会返回void，可用于为某些成员变量设初始值，类的构造函数如果我们不明确写是不会出现在类中的，

class A{
    private:
        int length,width,cnt;
    public:
        A();//构造函数
        void s(int l,int w);
}

A :: A(){
    printf("this obj is being created!\n");
}
//or
A :: A(int c){
	cnt = c;
    printf("this obj is being created!\n");
}
//or,这上下两个等价
A :: A(int c):cnt(c){
    printf("this obj is being created!\n");
}
void A::s()
{
    length = l;
    width =w;
    printf("%d\n",width*length);
}
int main(int argc, char const *argv[])
{
    int l=2,w=3;
    A A_1;
    A_1.s(l,w);
    return 0;
}

初始化多个变量：

Class :: Class(int a,int b,int c):object1(a),object2(b),object3(c){
...
}

析构函数：
类的析构函数是类的一种特殊成员函数，他会在每个删除所创建的对象的时候会调用这个函数，析构函数的名称和类的名称是完全相同的，只是这个函数名前面加‘~’作为前缀，和构造函数一样，这个函数不会返回任何值，也不能带任何参数，析构函数有助于跳出程序（关闭文件，释放内存）前释放资源。

class A{
    private:
        int length,width,cnt;
    public:
        A();//构造函数
        void s(int l,int w);
        ~A();//析构函数
}

A :: A(){
    printf("this obj is being created!\n");
}
//or
A :: A(int c){
	cnt = c;
    printf("this obj is being created!\n");
}
//or,这上下两个等价
A :: A(int c):cnt(c){
    printf("this obj is being created!\n");
}
A :: ~A(){
	printf("this obj is being deleted!\n");
}
void A::s()
{
    length = l;
    width =w;
    printf("%d\n",width*length);
}
int main(int argc, char const *argv[])
{
    int l=2,w=3;
    A A_1;
    A_1.s(l,w);
    return 0;
}

每个对象调用析构函数的时候，顺序和定义是相反的，构造函数和析构函数调用顺序如下：
class obj1,obj2,obj3;
class 1 2 3,~class 3 2 1;
8.拷贝构造函数
类的拷贝时使用；
9.友元函数
C++中类对对象进行封装，但如想访问封装的数据成员需要用到友元函数。类的友元函数是定义在类的外部，但是有权访问类中的private和protected成员，尽管友元函数在类的定义中出现过，但友元函数不是类的成员函数。
要声明函数为一个类的友元，需要在类的定义中这个函数原型前使用关键字friend，

class A{
    private:
        int length,width;
    public:
        A();//构造函数
        friend void s(int l,int w);//友元函数
        ~A();//析构函数
}
void s(int l,int w){
length=l;
width=w;
printf("%d",length*width);}

10.内联函数
在类中定义的函数都是内联函数，即使没使用inline关键字。
11.this指针
在C++中每一个对象都能通过this指针访问自己的地址，this指针是所有成员函数的隐含参数，因此在成员函数的内部，this指针可以用来指向调用的对象，但友元函数是没有this指针的，因为它不是类的成员函数。只有成员函数才有this指针

class A{
    private:
        int length,width;
        int res;
    public:
        A();//构造函数
        friend void s(int l,int w);//友元函数
        bool compare(A this_s);
        ~A();//析构函数
}

A :: A(){
    printf("this obj is being created!\n");
}
void A::s()
{
    length = l;
    width =w;
    res = width*length;
    printf("%d\n",width*length);
}
bool A::s(A this_s)
{
    if(this->res >this_s.res)return 1;
    return 0;
}
int main(int argc, char const *argv[])
{
    int l=2,w=3,x=4,z=2;
    A A_1,A_2;
    A_1.s(l,w);
    A_2.s(x,z);
    if(A_1.compare(A_2)){
        printf("The frist box is larger than the second box");
    }
    else{
        printf("The first box is equal or smaller than the second box");
    }
    return 0;
}

12.指向类的指针
一个指向类的指针和指向结构的指针类似，访问指向类的指针的成员通常需要运算符->和访问指向结构的指针一样，在使用指针前需要初始化。

A *p;
p=&A_1;
p->s();

13.类的静态成员
假如我们需要一个变量统计创建的对象数量，这个变量在每个对象中是公共的，都可修改和使用，值不因对象的删除和改变而改变，这就要用到静态成员。
使用static关键字把成员定义为静态的，不能把静态成员初始化放在类的定义里，要在类外声明从而初始化。

class A{
    private:
        int length,width;
        static int res;
    public:
        A();//构造函数
        friend void s(int l,int w);//友元函数
        bool compare(A this_s);
        ~A();//析构函数
}

int A :: res = 0;

---

学习时间：

• 周2上午 9 点-上午 6 点

学习产出：

CSDN 技术博客 1 篇