C++类的总结

最新推荐文章于 2025-02-13 16:51:12 发布
最新推荐文章于 2025-02-13 16:51:12 发布
阅读量157 收藏 1
点赞数 6
文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/m0_62846938/article/details/133875742
版权

C++

C++作为面向对象的一种语言，可以把一切具有相同特性的客观事物抽象出形成类，所以类也是c++语言中非常重要的一环。

C++类的定义

所有类的定义都是class+类名，后面跟{}；一个类里面应该有的成员：

1.三种访问修饰符：private(私有成员)，public(公有成员)，protect(保护成员)；

2.构造函数，析构函数，普通成员函数； 

3.成员变量。

所有的成员变量和成员函数都是用来起到修饰对象的作用，即都是对象的属性。

接下来是一段定义的代码:

class SStudent{
     private:
        char name[20];
        int age;
        int ID;
};

 这是一个学生类的定义，私有化内的三个成员变量皆为学生的属性。

类的对象&成员函数

对象

对象的定义形式为：类名 对象名；（与变量的定义有些类似）

对于一般的对象来说，每个对象都有自己的存储空间，一个对象内的成员变量被改变并不会影响其他对象内的成员。

一个对象的大小=对象内所有成员变量大小之和。

class SStudent{
     private:
        char name[20];
        int age;
        int ID;
};
int main()
{
    SStudent student;
    return 0
}

sizeof(student)=sizeof(name)+sizeof(age)+sizeof(ID)=9

类访问成员变量成员函数有三种方法：

1、对象名.成员名

class SStudent{
     private:
        char name[20];
        int age;
        int ID;
     public:
        int output()
{
      cout<<"HelloWord!"<<endl;
}
};
int main()
{
    SStudent student;
    student.age=18;
    student.output;
    cout<<student.age<<endl;
    return 0
}

运行结果

HelloWord!

18

2、指针->成员名

SStudent student1,student2;///定义SStudent类的两个对象

SStudent *p1=&student1;

SStudent *p2=&student2;

p1->age=20;//对象studentd1的年龄被修改为20

p2->ID=110110;//对象student2的学号被修改为110110

3、引用名.成员名

SStudent student;

SStudent s&student;

s.age=18;//对象student的年龄被修改为18

引用就相当于该对象的一个别名，并不会开辟新的内存空间，而是与对象共用一个内存空间。这里不做过多详解。

成员函数

本版块成员函数为普通成员函数，不进行过多分类。

成员函数的声明定义和调用

1、成员函数的定义与c语言的普通函数定义无异，都是类型名+函数名（类型名 形参名，类型名 形参名...）{}。

其中，声明时可以省略形参名，定义不可省略。

2、成员函数的调用与对象调用方式相同

对象名.成员函数名

指针名->成员函数名

引用名.成员函数名

内联函数和重载成员函数

内联成员函数

1、成员函数整体的声明与定义都在类的内部

class SStuednt{

        private:

                int age;

        public:

                void func(int i)

{

                  age=i;

                  cout<<"run successfuly!"<<endl;

}

};

  2、在类内进行声明，类外进行定义（声明时需要在类前加上inline,定义时在函数名前加上类名）

class SStuednt{

        private:

                int age;

        public:

              inline  void func(int i);

};

void SStudent::func(int i)

{

                  age=i;

                  cout<<"run successfuly!"<<endl;

}

以上为定义内联函数的两种方式，内联函数的作用就是可以解决函数频繁调用的问题。使用内联函数，在编译器编译时就会把程序中调用内联函数的部分换成内联函数结构体，而其他函数只有在运行时才会替转。

重载成员函数

重载需满足两点：

1、函数名相同

2、形参个数不同/形参类型不同/形参类型顺序不同

通过以下例子可以更直观了解

#include<iostream>

using namespace std;

class SStuednt{

        private:

                int age;

                int ID;

        public:

                void func(int i,int j){age=i;ID=j;};

                void func(int i,int j=110110){age=i;ID=j}

                int func(){return age};          

};

int main()

{

        SStudent student;

        student.func(18,110111);       

        student.func(23);

        cout<<student.func()<<student.ID<<endl; 

        return 0;

}

运行结果

23 110110

当调用重载函数时，系统会自动根据实参的类型个数来匹配相应的重载函数。

构造函数

构造函数的作用是对对象进行初始化，给成员变量赋初值；

名字与类名相同，一个类只能有一个构造函数，可以有参数但是不能有返回，构造函数可以重载;

如果定义类时不写构造函数的话，系统会自动生成一个默认构造函数，默认构造函数无参且什么也不做。

形式为 ：类名（）

class SStuednt{

        private:

                int age;

                int ID;

        public:

                SStudent(){}//默认构造函数，什么也不做

                SStuednt(int i,int j){age=i;ID=j; cout<<"succseefuly!"<<endl;}//自己创建的构造函数，用来初始化成员变量

                SStudent（int i,int j）:age(i),ID(j)//初始化的另一种方式，初始化列表

};

int main()

{

        SStudent student1;//无参会调用默认构造函数进行初始化，初始值随机

        SStudent student2(18,110110);//调用第二个函数进行初始化

        return 0;

}

初始化列表的使用方式：

类内：构造函数名（参数表）：成员变量1（参数表），成员变量2（参数表），...

类外： 类名：：构造函数名（参数表）：成员变量1（参数表），成员变量2（参数表），...

析构函数

析构函数名也与类名相同，但是没有参数也没有返回值，一个类只能有一个析构函数；

析构函数的命名规则是：~ 类名

析构函数在对象消亡时自动被调用，主要做对象消亡前的善后工作，如释放内存；

如果类内不进行析构函数的定义，系统则会自动生成一个缺省析构函数；

析构函数秉承先被构造的对象后被析构（作用域不同的对象除外）

通过以下代码进行进一步理解：

#include<iostream>
using namespace std;
class Demo{
		int id;   
	public:
		Demo(int i)
		{
			id=i;
			cout<<"id="<<id<<"Constructed"<<endl;//在执行构造函数时就会打印id的值和constructde
		}
		~Demo()//在执行析构函数时就会打印输出当前id的值和后面这句话
		{
			cout<<"id="<<id<<"Deestructed"<<endl;
		}
};
Demo d1(1);
void Func(){
	static Demo d2(2);
	Demo d3(3);
	cout<<"Func"<<endl;
}
int main()
{
	Demo d4(4);
	d4=6;
	cout<<"main"<<endl;
	{ Demo d5(5);	}
	Func();
	cout<<"main ends"<<endl;
	return 0;
}

运行结果：

 id=1Constructed
id=4Constructed
id=6Constructed
id=6Deestructed
main
id=5Constructed
id=5Deestructed
id=2Constructed
id=3Constructed
Func
id=3Deestructed
main ends
id=6Deestructed
id=2Deestructed
id=1Deestructed

复制构造函数

复制构造函数，也叫拷贝构造函数；

命名形式如下 类名（const 类名 &对象名）

SStudent（const SStudent &student ）

复制构造函数起作用的三种情况：

1、一个对象被同类的另一个对象初始化时

#include<iostream>

using namespace std;

class SStuednt{

        private:

                int age;

                int ID;

        public:

                void func(int i,int j){age=i;ID=j;}        
                int func(){return age}        
                ~func(){}

};

int main()

{

        SStudent student1(18,110110);
        SStudent student2(student1);
        cout<<student2.age<<student.ID<<endl;
        return 0;

}

运行结果

18 110110

2、某函数的一个参数为类A的对象，当该函数被调用时

class A{

        private:

                int a;

        public:

                A(){}//默认构造函数

                ~A(){}//默认析构函数

}；

void func(A a1){}

int main()

{                      

        A a2;

        func(a2);

        return 0;

} 

3、某函数的返回值为类A的对象，当函数值返回时，调用复制构造函数

class A{

        private:

                int a;

        public:

                A(int i){a=i;}

                ~A(){}//默认析构函数

                A(const A&n){a=n.a}

}；

void A func()

{

        A b(3);

        return b;

}

int main()

{                      

       cout<<func().a<<endl;

} 

运行结果

3

静态成员和静态成员函数

在成员变量前加上static定义为静态成员变量

静态成员在类的所有对象中是共享的，即不存在单独的对象，只有共同的对象。

sizeof运算符计算大小时不会计算静态成员的大小

class SStudent{

        int a;

        int static b;

};

此时sizeof(SStudent)=4

访问静态成员有三种方法：

类名::成员名          SStudent::b

对象名.成员名       student.b

指针->成员名         p->b

在静态成员函数中，不能访问非静态成员变量，也不能调用非静态成员函数。

友元

友元函数

友元函数的作用：一个类的友元函数可以访问该类的私有成员

通过一段代码进行深入认识

#include<iostream>
using namespace std;
class CCar;
class CDriver{
	public:
		void ModifyCar(CCar*pCar);
};
class CCar{
	private:
		int price;
	friend int MostExpensiveCar(CCar cars[],int total);
	friend void CDriver::ModifyCar(CCar *pCar); 
};
void CDriver::ModifyCar(CCar*pCar)
{
	pCar->price+=1000;
} 
int MostExpensiveCar(CCar cars[],int total)
{
	int tempMax=-1;
	for(int i=0;i<total;++i)
		if(cars[i].price>tempMax)
			tempMax=cars[i].price;
	return tempMax;
}
int main()
{
	return 0;
}

友元类

与友元函数作用类似

A是B的友元类，A的成员函数就可以访问B的私有成员

class B{

        private:

                int a,b;

        public:

                B func1();

        friend class A;

};

class A{

        plublic:

                int c;

                func2(){c+=a+b}

};

int main(){

        return 0;

}

友元类不能传递，不能继承。

this指针

在同一个类中，每个对象都可以通过this指针来访问自己的地址，作用就是指向成员函数所作用的对象。

this的特性：

1. this指针的类型：类名* const。
2. 只能在“成员函数”的内部使用。
3. this指针本质上其实是一个成员函数的形参，是对象调用成员函数时，将对象地址作为实参传递给this形参。所以对象中不存储this指针。
4. this指针是成员函数第一个隐含的指针形参，一般情况由编译器通过ecx寄存器自动传递，不需要用户传递。

#include<iostream>
using namespace std;
class SStudent{
    private:
        int age;
        int ID;
    public:
         void func(){cout<<age<<" "<<ID<<endl;}
         SStudent(int _age,int _ID){age=_age,ID=_ID;}
};
int main()
{
    SStudent s1(18,110110);
    SStudent s2(20,110111);
    s1.func();
    s2.func();
    return 0;
}

运行结果

18 110110

20 110111

上面代码如果写出隐藏的this指针如下，方便大家理解

#include<iostream>
using namespace std;
class SStudent{
    private:
        int age;
        int ID;
    public:
         void func(SStudent const *this){cout<<this->age<<" "<<this->ID<<endl;}
         SStudent(SStudent *this int _age,int _ID){age=_age,ID=_ID;}
};
int main()
{
    SStudent s1(18,110110);
    SStudent s2(20,110111);
    s1.func(&s1);
    s2.func(&s2);
    return 0;
}

可以看出this指针是const型，不可被更改。 

C/C++学习路线总结与分享
dvlinker的技术专栏
10-07 10万+
C/C++学习路线总结与分享
【C++软件调试技术】C++软件开发维护过程中典型软件异常问题的排查与总结
热门推荐
dvlinker的技术专栏
04-15 16万+
本文以问答的方式进行展开，罗列了C++软件日常开发和维护中遇到的多个软件调试问题及有代表性的场景，给出详细的处置思路和处理办法，以供大家借鉴和参考。
c++ 学习---类的设计总结
少帅的天空
04-01 1084
1 编译器生成的成员函数(1)默认构造函数   这个不做详细的介绍，相信的大家已经很了解了。(2)复制构造函数   className(const className &);在下述情况下将使用复制构造函数   a)将新的对象初始化为一个同类的对象   b)按值就对象传递给参数   c)函数按值返回对象   d)编译器生成临时对象 (3)复制操作符   c
02.【C++】类和对象（上）（class类的定义及使用、访问限定符public\private\protected、this指针）
最新发布
qq_54652195的博客
02-13 638
C++类的定义及使用，类中public，private，protected的作用，类的实例化，类实例化对象的存储及内存对齐规则；this指针的定义；C++与C语言实现Stack栈的对比
c++类总结
邵光亮的博客
04-12 808
一，定义 类的基本思想是数据抽象和封装。数据抽象是一种把接口和实现分离的编程技术。类的接口包括用户所能够执行的操作，类的实现包括类的数据成员、负责接口实现的函数体和各种私有函数。 封装实现了类的接口和实现的分离。封装隐藏了类的实现，封装过后，用户只能访问类的接口，而不能访问类的实现。 1.类的声明： 以数据成员的方式描述数据部分，以成员函数（被称为方法）的方式描述接口函数。 ​ cla...
c++ 类总结
weixin_60413769的博客
03-13 1118
这里是Joe本人的学习笔记，如果能帮助到你，那我受宠若惊！ 不知不觉学习c++类已经一周多了，这里给出我的总结，作为以后的复习资料。 类的基本知识 类的成员函数： 返回值类型 类名 ：： 函数成员名（参数表） { 函数体 } void Clock::set(int a,int b,int c){ 函数体 } 构造函数： 没有返回值，函数名与类名相同， Clock::Clock(int a,int b,int c){ 函数体 } 复制构造函数：
C++类 总结
weixin_45322525的博客
12-05 157
C++中使用关键字 class 来定义类, 其基本形式如下 class Point { public: void setPoint(int x, int y); void printPoint(); private: int xPos; int yPos; }; 代码说明：上述代码命名了一个为point的类。具有两个私密属性，int型的x点和y点，在方法上，用setPoint来设置点的值。 数据的抽象与封装 抽象是通过特定的实例抽取共同特征以后形成概念的过
【C++知识点总结全系列 (04)】：C++类的详细总结与分析
qq_42279379的博客
06-30 1066
1.类的概述：什么是类、类的作用、类对象的初始化、类的组成；2.类的访问权限：表格化呈现public、private、protected三种访问权限的区别和联系；3.友元：什么是友元、友元的作用；4.聚合类：什么是聚合类、聚合类的作用、如何使用如聚类；5.嵌套类：什么是嵌套类、嵌套类的作用、嵌套类的使用；6.局部类：什么是局部类、局部类作用；7.union类：What、Why、How、匿名union类；8.类成员指针：What、Why、How；9.类的转换：隐式转换和显式转换；
C++ 类访问控制的条件总结
01-20
C++类的重要属性就是封装和继承。因此，最关键的问题就是权限 的问题，public，protected，private 控制的就是访问权限。 public protected private 类成员是否可以访问 Yes Yes Yes 友元函数是否可以访问...
c++中的类总结
happy_xiahuixiax的博客
05-16 381
1：对于一个有封装性的类，主要通过公有消息和外界交互。 2：类的成员函数的定义，可以写在类里，也可以写在类外面，更常见的是写在类外。区别：编译时，写在类里的函数被编译器当做内连函数处理。 3：如果要将在类体外定义的成员函数声明为内联成员函数，只要在定义前加上inline。 4：在体内定义成员函数的方式与普通的定义方法相同。在类体外定义一个成员函数则要使用作用域运算符: : 格式为《inlin
[C++]类总结
FightFightFight的博客
11-21 417
1.类基础 1.1.类的声明 一般的习惯是，类的声明和定义分别在头文件和源文件中进行，声明一个类时，使用关键字class,语法如下： //Person.h #include &amp;amp;amp;lt;string&amp;amp;amp;gt; class Person { private: int age; std::string name; public: s...
C++总结——类
qq_43903506的博客
03-07 802
初始化列表 构造 析构
C++ 类知识点小总结
Rrrrya
06-12 565
一，类和对象 1，如果一个类体中没有一个访问权限关键字，则其中的数据成员和成员函数都默认为私有的。 class r { int a, b, c; // 默认为私有数据成员 }; 2，只有在类的对象定义之后才能给数据成员赋值。 class r { private: int a = 80; // 错误 int b = 100; // 错误 }; 3，定义对象时，若定义的是指针变量，则访问此对象的成员的时不能使用 ‘ . ’操作符，而应该使用‘ -> '操作符。 #include
c++类（ii）知识总结
m0_64120172的博客
02-10 309
1. 为了减少占用存储空间，将各个对象的数据成员存储在程序数据区，把成员函数的代码统一放在程序的代码区。 定义对象时，系统给对象分配的内存只是来存储其数据成员。 2.类的每个非静态成员函数都含有一个指向调用它的对象的指针，叫做this指针。 This指针指向正在操作该成员函数的对象。 当对一个对象调用非静态成员函数时，编译程序先将对象的地址赋给this指针，然后调用成员函数。。 3.成员函数不能再显式定义this指针，编译器显式定义 4.必须显式使用this指针的一种...
C++入门教程（8）类的私有成员 （private）
CV战士的日常
03-06 8560
上节我们定义了一个Person类，这一届我们继续深入学习类 过年了，假设小明的爸爸和妈妈分别给了小明和小红每人100元的压岁钱，我们用程序来实现这个压岁钱的属性。给Person类定义一个新的成员 money class Person{ public: //布尔类型 bool isBoy ; //整形 int age; //浮点型 float height; //字符型 string name ; //压岁钱
14.1 C++类-成员函数、对象复制与私有成员
migu123的专栏
02-22 812
1.成员函数、对象复制与私有成员 1.1 总述 1.2 类基础 1.3 成员函数 1.4 对象的复制 1.5 私有成员
C++基础知识概览与总结
资源摘要信息: "c++总结_ThereThere_c++总结_" 1. C++简介 C++是一种静态类型、编译式、通用的编程语言，由Bjarne Stroustrup在1980年代初期在贝尔实验室开发。C++支持多种编程范式，包括过程化、面向对象和泛型...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值