C++入门之类

最新推荐文章于 2023-08-04 01:31:33 发布

123.com

最新推荐文章于 2023-08-04 01:31:33 发布

阅读量140

点赞数

分类专栏： C++ 文章标签：类和对象

本文链接：https://blog.csdn.net/qq_38810767/article/details/85019152

版权

C++ 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

本次将初步介绍类和对象分为以下几个阶段：
1.类与对象的初步认知
2.类的引入
3.类的定义
4.类的作用域
5.类的实例化
6.类的访问限定符及封装
7.类的对象大小的计算
8.类成员函数的this指针

1.类与对象的初步认知

首先要知道类是所有面向对象的语言的共同特征，所有面向对象的语言都提供了这种类型。

类的概念：类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作封装在一起。

对象的概念是具有类类型的变量。类是对象的抽象，而对象是类的具体实例。类是抽象的，不占用内存，而对象是具体的，占用存储空间。类是用于创建对象的蓝图，它是一个定义包括在特定类型的对象中的方法和变量的软件模板。C++中的类实际上就是由一组描述对象属性或状态的数据项和作用在这些数据项上的操作构成的封装体。类的定义由关键字class打头，关键字后跟类名，类名之后的括号内是类体，最后以“；”结束。

2.类的引入

举个例子：现实世界中的学生，在计算机中的反应；
如何定义一个类：首先是属性，然后是行为；
学生的属性有哪些，简单的说几个，长得好看，性别，年龄，名字等；
学生行为下面的代码就是打印出来姓名学号和年龄等输入的属性信息；当然行为很多，只是举了个简单的例子
属性：在计算机中表示就是变量
行为：在计算机中的表示就是函数

class student{
public:

//行为：输入属性信息；
void SetstudentInfo(const char*name,const char*gender,int age){
strcpy(_name,name);
strcpy(_gender,gender);
_age=age;
}
//行为：输出属性信息
viod PrintstudentInfo(){
cout<<_name<<" "<<_gender<<" "<<_age<<endl;
}
//这是类的属性
private:
char _name[20];
char _gender[3];
int _age;

};
int main(){
 Student s;//对象,实例化   
 s.SetStudentInfo("Peter", "男", 18); 
 s.PrintStudentInfo();  
 return 0;
}

3.类的定义

class className {

// 类体：由成员函数和成员变量组成
}; // 一定要注意后面的分号

class为定义类的关键字，ClassName为类的名字，{}中为类的主体，注意类定义结束时后面分号。类中的元素称为类的成员：类中的数据称为类的属性或者成员变量; 类中的函数称为类的方法或者成员函数。

类的两种定义方式：
在说类定义方式前先引入一下内联函数
什么是内联函数？
　内联函数是代码被插入到调用者代码处的函数。如同 #define 宏，内联函数通过避免被调用的开销来提高执行效率，尤其是它能够通过调用（“过程化集成”）被编译器优化。 宏定义不检查函数参数，返回值什么的，只是展开，相对来说，内联函数会检查参数类型**，所以更安全。**
　　内联函数和宏很类似，而区别在于，宏是由预处理器对宏进行替代，而内联函数是通过编译器控制来实现的。而且内联函数是真正的函数，只是在需要用到的时候，内联函数像宏一样的展开，所以取消了函数的参数压栈，减少了调用的开销。你可以象调用函数一样来调用内联函数，而不必担心会产生于处理宏的一些问题。
　　总结：
宏函数的优点：代码运行效率高，在预处理阶段，用函数替换调用位置上替换；没有调用开销；没有参数压栈等操作
缺点：不会编译，在预处理阶段，不会进行参数检测，代码的复用性不好，代码膨胀；
内联函数的优点：继承了宏的优点，而且宏函数的缺点他都改善了；
缺点：在本文中有效，而且如果有时候有些函数会被编译器默认为内联函数，即使自己没有定义这个函数为内联函数；而且内联函数也有一定的局限性。就是函数中的执行代码不能太多了，如果，内联函数的函数体过大，一般的编译器会放弃内联方式，而采用普通的方式调用函数。这样，内联函数就和普通函数执行效率一样了。

内联函数定义：
1.当你定义一个内联函数时，在函数定义前加上 inline 关键字，并且将定义放入头文件：
意思就是：在头文件声明的时候就必须加上定义。
inline void f(int i, char c)
{
// …
}
内联函数必须是和函数体定义在一起**，才有效。像这样的声明Inline Tablefunction(int I)是没有效果的，编译器只是把函数作为普通的函数申明，我们必须定义函数体。
Inline tablefunction(int I) {return I*I};
2.类里面的函数有可能会被编译器默认为内联函数，即使没有加inline关键字；
那么什么时候会呢？
这个一般是函数体小，使用频繁，没有循环，很少的判断语句；整体来说就是简短；
比如：
Class TableClass{
　Private:
　　Int I,j;
　Public:
　　Int add() { return I+j;};
　　Inline int dec() { return I-j;}
　　Int GetNum();
}
inline int tableclass::GetNum(){
return I;
}
上面声明的三个函数都是内联函数。在C++中，在类的内部定义了函数体的函数，被默认为是内联函数。而不管你是否有inline关键字。
现在开始说类的定义
类的两种定义方式：
1. 声明和定义全部放在类体中
需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数处理。
即下面这种

#include <iostream>
#include<stdlib.h>
using namespace std;

class student{
public:
//行为：输入属性信息；
void SetstudentInfo(const char*name,const char*gender,int age){
strcpy(_name,name);
strcpy(_gender,gender);
_age=age;
}
//行为：输出属性信息
viod PrintstudentInfo(){
cout<<_name<<" "<<_gender<<" "<<_age<<endl;
}
//这是类的属性
private:
char _name[20];
char _gender[3];
int _age;

};
int main(){
 Student s;//对象   
 s.SetStudentInfo("Peter", "男", 18); 
 s.PrintStudentInfo();  
 return 0;
}

2. 声明放在.h文件中，类的定义放在.cpp文件中

//声明放在student.h 文件中
class student{
public:

//行为：输入属性信息；
void SetstudentInfo(const char*name,const char*gender,int age);
//行为：输出属性信息
viod PrintstudentInfo();

//这是类的属性
private:
char _name[20];
char _gender[3];
int _age;

};

//定义在student.cpp 文件中
#include <stuent.h>
//此时定义的时候要加类名和作用域限定符：： ，意思是对class里面的函数进行定义
void student::SetstudentInfo(const char*name,const char*gender,int age){
strcpy(_name,name);
strcpy(_gender,gender);
_age=age;
}
//行为：输出属性信息
viod student::PrintstudentInfo(){
cout<<_name<<" "<<_gender<<" "<<_age<<endl;
}

一般情况下，更期望采用第二种方式。

4.类的作用域

现在说类的作用域：

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类体外定义成员，需要使用 :: 作用域解析符 指明成员属于哪个类域。

//在类外定义

 class Person { 
 public: 
 
  void PrintPersonInfo();
  
   private: 
   char _name[20];
   char _gender[3];
    int  _age; };
 
// 这里需要指定PrintPersonInfo是属于Person这个类域
 void Person::PrintPersonInfo() {   
 
   cout<<_name<<" "_gender<<" "<<_age<<endl;
   
    }

5.类的实例化

类的实例化：
怎么说呢
1.用类类型创建对象的过程，称为类的实例化；
2. 一个类可以实例化出多个对象，实例化出的对象占用实际的物理空间，存储类成员变量

做个比方。类实例化出对象就像现实中使用建筑设计图建造出房子，类就像是设计图，只设计出需要什么东西，但是并没有实体的建筑存在，同样类也只是一个设计，实例化出的对象才能实际存储数据，占用物理空间

房子能住人，但是图纸不能住人，所以对象占用物理空间，类不占用

现在举个例子：
把类比作房子的设计图纸，那么对象就是根据图纸盖出来的房子；中间怎么盖的，那就不操心了；

下面是类，既图纸

#include <iostream>
#include<stdlib.h>
using namespace std;

class student{
public:
//行为：输入属性信息；
void SetstudentInfo(const char*name,const char*gender,int age){
strcpy(_name,name);
strcpy(_gender,gender);
_age=age;
}
//行为：输出属性信息
viod PrintstudentInfo(){
cout<<_name<<" "<<_gender<<" "<<_age<<endl;
}
//这是类的属性
private:
char _name[20];
char _gender[3];
int _age;

};

这是对象：即房子
类名加对象名就把对象定义好了

student+ s；

int main(){
 Student s;//对象 
 s.SetStudentInfo("Peter", "男", 18); 
 s.PrintStudentInfo();  
 return 0;
}

以上过程就是类的实例化过程

6.类的访问限定符及封装

首先：先说一下访问修饰符
1.public:公有的直接访问
2.private:私有的，不能够直接访问
3.protected:受保护的，不能够直接访问
4. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止
5. class的默认访问权限为private，struct为public(因为struct要兼容C)

注意：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别

这句话的意思就是，访问修饰符只是给编译器看的，告诉编译器这个是私有的还是公中的，能不能访问，如果是私有的，其他地方访问就会出错。和内存没关系，也不好给内存画界限说这个地方不能访问。

那么在这里说一下struct和class的****区别：
答：C++需要兼容C语言，所以C++中struct可以当成结构体去使用。另外C++中struct还可以用来定义类。
和class是定义类是一样的，区别是struct的成员默认访问方式是public，
class是struct的成员默认访问方式是private。

额外的说一下封装：

封装

：封装就是将对象的数据和操作数据的方法进行有机的结合，隐藏对象的属性和实现细节，仅对外提供接口和对象进行交互；
封装本质上是一种管理：我们如何管理兵马俑呢？比如如果什么都不管，兵马俑就被随意破坏了。那么我们首先建了一座房子把兵马俑给封装起来。但是我们目的全封装起来，不让别人看。所以我们开放了售票通道，可以买票突破封装在合理的监管机制下进去参观。类也是一样，我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。

7.类的对象大小的计算

计算规则：一个类的大小，实际就是该类中”成员变量”之和，当然也要进行内存对齐，注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类。

上面说了在c++中struct和class都可以定义类：

那么我们可以想象到struct大小的和class大小计算规则一样么？
答案：在C语言中 struct中还不能定义函数；它的大小计算规则，涉及到内存对齐；
这个时候，他和class的计算规则一样；都只是针对变量来计算，函数不参与其中

说完了这个，唠叨几句：
为什么要内存对齐？
大概有以下两个原因：

平台原因（移植原因）：不是所有的硬件平台都能访问任意地址上的任意数据，某些平台只能在某些地址处取某些特定的类型数据，否则抛出硬件异常。
性能原因：数据结构（尤其是栈）应该尽可能的在自然边界上对齐。原因在于，为了访问未对齐的内存，处理器需要做两次内存访问；而对齐的数据仅需要一次就行了；

简单的说了：有些平台不对齐就没法访问内存上的数据，还有就是对齐了数据访问效率高，对齐了是cpu访问最快了

结构体内存对齐规则：

第一个成员在与结构体偏移量为0的地址处。
其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。注意：对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。 VS中默认的对齐数为8，gcc中的对齐数为4
结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数
如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍

举个例子：

struct A
{
char   c; //1byte
double d; //8byte
short s; //2byte
int i; //4byte
};

看下图的时候结合以上的四个概念：
在这里插入图片描述
这个大小为24
**如果嵌套结构体，先计算里面的结构体大小，然后把它当成一个外面的结构体成员进行计算就行了

struct Args {         
 char ch;  
        
 double d; 
         
 short st;
           
 char rs[9];         
 int i; 
 
 } args;
  struct Argsa {    
       
  char ch;      
      
  Args test;  
         
  char jd[10]; 
          
  int i; 
  
  }arga;

第一个结构体为32 ，计算到数组的时候就比较恶心了，和上一个成员对齐看类型，下一个成员对齐就要看整体的大小了

第二个为56

计算过程中最容易忘的：
这两句话不容易理解，多想想
对齐数 = 编译器默认的一个对齐数与该成员大小的较小值。
还有就是结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数

说完这些：那么其实和结构体计算差不多；但是只是计算类中的成员，函数不算，
再要注意空类的大小，不同编译器给空类大小不一样，主流的编译器都是给一个字节；

8.类成员函数的this指针

this指针：

#include<iostream>
#include<stdlib.h>
using namespace std;
class data{
public:
	void PrintA(int a){
		_a = a;
		cout << _a << endl;
	}
	void PrintB(){


		cout << "printb" << endl;
	}
private:
	int _a;
};
int main(){
	data d1，d2;
	d1.PrintA(1);
	d2.PrintA(3);
	return 0;
}

对于上述类，有这样的一个问题：
函数体中没有关于不同对象的区分，那当d1调用PrintA函数时，该函数是如何知道应该设置d1对象，而不是设置d2对象呢
在C语言中定义一个结构体；传参的时候都要传入结构体的地址，而在这里没有；其实也是有的，只是我们看不见；
C++中通过引入this指针解决该问题，即：C++编译器给每个“成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有成员变量的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成

this指针的特性 ：

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

每一个对象都有一个都有一个隐式的指针形参，且是第一个形参
编译器的传递方式：将对象地址作为实参，传递给成员函数的this指针；

this指针在哪儿：中C++ 编译器会放在 ECX 寄存器里，GCC 会把 this 指针作为第一个推入栈中的参数。

除此之外this指针不可以为空?

看看_thiscall的调用约定：
（1）_thiscall只能用在类的成员函数上。
（2）参数从左向右压栈。
（3）如果参数个数确定，this指针通过ecx传递给被调函数，如果不参数确定，this指针所在的参数被压栈后压入栈中。
（4）对于参数不定的，调用者清理堆栈，否则函数自己清理堆栈。
可以看出每次成员函数调用时，this都会被压栈。

#include<iostream>
#include<stdlib.h>
using namespace std;
class data{
public:
	void PrintA(int a){
		_a = a;
		cout << _a << endl;
	}
	void PrintB(){


		cout << "printb" << endl;
	}
private:
	int _a;
};
int main(){
	data d1;
	//d1.PrintA(1);
	d1.PrintB();
	d1.PrintA(1);
	data *p = NULL;
	//p->PrintA(1);
	p->PrintB();
	return 0;
}

p->PrintA(1);只执行这句出错
p->PrintB();只执行这句没问题
这说明只要不通过this指针访问类中成员就可以为空;

123.com

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
C++入门之类

本次将初步介绍类和对象分为以下几个阶段：1.类与对象的初步认知2.类的引入3.类的定义4.类的作用域5.类的实例化6.类的访问限定符及封装7.类的对象大小的计算8.类成员函数的this指针1.类与对象的初步认知首先要知道类是所有面向对象的语言的共同特征，所有面向对象的语言都提供了这种类型。类的概念：类是现实世界或思维世界中的实体在计算机中的反映，它将数据以及这些数据上的操作...
复制链接

扫一扫