类和对象(1)

已于 2022-01-21 11:56:26 修改
阅读量214 收藏
点赞数
分类专栏： C++ 文章标签： c++
于 2022-01-15 18:39:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zstuyyyyccccbbbb/article/details/122513998
版权

文章目录

1.面向过程和面向对象的初步认识

C语言是面向过程的，关注的是过程。分析出求解问题的步骤，通过函数调用逐步解决问题。

C++是基于面向对象的，关注的是对象，将一件事情拆分成不同的对象，靠对象之间的交互完成。

2.类的引入

C语言中，结构体只能定义变量，在C++中，结构体内不仅可以定义变量，也可以定义函数。C++更喜欢用class来代替。

3.类的定义

类中的元素称为类的成员，类中的数据称为类的属性或者类的成员变量。

类中的函数称为类的方法或者成员函数。

//类里面可以定义： 1.成员变量 2.成员方法
class Person
{
 	char _name[10];//一般定义名字建议加上_
    int _age;
    //..
    void Print()
    {
        
    }
};

类的两种定义方式

  1. 声明和定义全部放在类体中，需要注意：成员函数如果在类中定义，编译器可能会将其当成内联函数理解。

    1. class Person{
    public:
    	void show()
        {
            cout<<_name<<"_"<<_sex<<"_"<<_age<<endl;
        }
    public:
    	string _name;
    	string _sex;
    	string _age;
}

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

    1. class Person
{
     public:
    	void show();
    public:
    	string _name;
    	string _sex;
    	string _age;
}

    2. #include "person.h"
void Person::show()
{
     cout<<_name<<"_"<<_sex<<"_"<<_age<<endl;
}

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

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

4.1访问限定符

C++实现封装的方式：用类将对象的属性与方法结合在一块，让对象更加完善，通过访问权限选择性地将其接口提供给外部的用户使用。

  1. public修饰的成员在类外可以直接被访问
  2. protected和private修饰的成员在类外不能直接被访问（此处protected和private是类似的）
  3. 访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现为止
  4. class的默认访问权限为private，struct为public（因为struct要兼容C）
  5. 注：访问限定符只在编译时有用，当数据映射到内存后，没有任何访问限定符上的区别。
  6. 访问限定符锁的是针对类外面的。内部没事

面试题：C++中struct和class的区别

C++要兼容C语言，所以C++中struct可以当作结构体使用。另外C++中struct还可以用来定义类，和class定义类的是一样的，区别是struct的成员默认访问是public，但是class是private。

class Student
{
    public:
    	void ShowInfo()
        {
            cout<< _name<<endl;
            cout<< _age<<endl;
            cout<<_stuid<<endl;
        }
    	
    	void GetAge()
        {
            return _age;
        }
    
    private://一般情况下成员变量都是比较隐私的，都会定义成私有或者保护
    char _name[20];
    int _age;
    int _stuid;
    
    
}


int main()
{
    Student s1;
    Student s2;
    s1._age = 10;//error:private
}

4.2封装

面向对象的三大特性：封装、继承、多态。

什么是封装：将数据和操作数据的方法进行有机结合，隐藏对象的属性和实现细节，仅对外公开接口来和对象进行交互。

封装本质上是一种管理。我们使用类数据和方法都封装到一下。不想给别人看到的，我们使用protected/private把成员封装起来。开放一些共有的成员函数对成员合理的访问。所以封装本质是一种管理。

5.类的作用域

类定义了一个新的作用域，类的所有成员都在类的作用域中。在类外定义成员，需要：：作用域解析。

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

6.类的实例化

用类类型创建对象的过程，称为类的实例化。

  1. 声明和定义的区别？声明认为是一种承诺，承诺要干嘛，但是还没做，定义就是把这个事给落实了。
  2. 如何定义一个类–类实例化出对象
//封装
// 1.将数据和方法放到定义一起
// 2.把想给你看到的数据给你看，不想给你看封装起来。--访问 限定符
//此时都是声明。这里的类是图纸，没有申请空间
class Stack
{
    //1.成员函数
    public:
    	void Push(int x);  //在类里面定义
    	void Pop();	//在类里面声明，类外面定义
    	bool Empty(); //这里是声明
    private:
    //2.成员变量
    	int* _a;
    	int _size;
    	int _capacity; //这里是声明
};
void Stack::Pop()
{
    //...
}
int main()
{
    //类实例化出对象，相当于定义出了类的成员变量
    Stack s1;
    Stack s2;
    Stack s3;
    
}

7.类对象模型

7.1如何计算类对象的大小

//封装
// 1.将数据和方法放到定义一起
// 2.把想给你看到的数据给你看，不想给你看封装起来。--访问 限定符
//此时都是声明。这里的类是图纸，没有申请空间
class Stack
{
    //1.成员函数
    public:
    	void Push(int x);  //在类里面定义
    	void Pop();	//在类里面声明，类外面定义
    	bool Empty(); //这里是声明
    private:
    //2.成员变量
    	int* _a;
    	int _size;
    	int _capacity; //这里是声明
};
void Stack::Pop()
{
    //...
}
int main()
{
    //类实例化出对象，相当于定义出了类的成员变量
    Stack s1;
    Stack s2;
    Stack s3;
    s1._a=nullptr;
    s1.Push(1);
    //对象中只存储成员变量，不存储成员函数。
    //因为一个类实例化出N个对象，每个对象的成员变量都可以存储不同的值，但是调用的函数确是同一个。
    //如果每个对象都存同样的函数，就浪费空间。
    //反汇编下可以看到函数是一样的。
    cout<<sizeof(s1)<<endl;//12
}

7.2类对象的存储方式

类对象里面只有成员变量

image-20220115185356400

只保存成员变量，成员函数存放在公共的代码段。

// 类中既有成员变量，又有成员函数
class A1 {
public:
 	void f1(){}
private:
 	int _a;
};
// 类中仅有成员函数
class A2 {
public:
 	void f2() {}
};
// 类中什么都没有---空类
class A3
{};

int main()
{
  	cout<<sizeof(A1)<<endl;
    cout<<sizeof(A2)<<endl;
    cout<<sizeof(A3)<<endl;
}

sizeof(类名)计算的就是实际上该类实例化后的大小。

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

7.3类存储的内存对齐规则

如何计算一个类的对象的大小，计算成员变量之和，并且考虑内存对齐规则。

内存对齐是必考

最大存储变量的整数倍。每个成员变量都有一个对齐数，这个对齐数=min（自己的大小，默认对齐数）

  • 没有成员变量的类的大小是1

    • 面试题：为什么是1不是0
    • A2 a2 、 A2 aa2 、 A2 aaa3 需要有地址表示对象的存在。

  • 结构体对齐规则

    • 第一个成员在结构体偏移量为0的地址处。
    • 其他成员变量要对齐到某个数字（对齐数）的整数倍处。
      • 注意：对齐数=编译器默认的一个对齐数与该成员大小的较小值
    • 结构体总大小为：最大对齐数（所有变量类型最大者与默认对其参数取最小）的整数倍
    • 如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。
class A1{
    public:
    	void f1(){};
    private:
    	int _a;
    	char _ch;
};//8个字节
//类中仅有成员函数
class A2{
    public:
    	void f2(){}
};//1
//空类
class A3
{};//1
int main()
{
    A2 aa;
    A2 bb;//1bytes区分对象
}

7.4相关题目

  1. 结构体怎么对齐？

  2. 为什么要进行内存对齐?

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

  3. 如何让结构体按照指定的对齐参数进行对齐?

    1. # pragma pack(2)   struct d
{
	char a; // 1  
	long  long b; // 8    
	short c; // 2 
};

  4. 什么是大小端？如何测试某台机器是大端还是小端，有没有遇到过要考虑大小端的场景？

    1. 我们在网络编程中，经常用到两台主机之间进行互发消息，这时候我们就需要进行考虑大小端的问题，因为两台主机的大小端不确定，有可能出现一个大端一个小端的情况，这样子就会产生歧义。

8.this指针

8.1this指针的理解

哪个对象调用这个函数，this就指向哪个对象的地址，同时成员函数中this默认加在第一个参数中

在使用友元运算符重载这个函数会有更加深刻的理解。

#include<iostream>
using namespace std;
class Date
{
    public:
    	void Init(int year,int month,int day)
        {
            //c++要用必须要先声明。但是这里却没有
            _year=year;//这里凭空访问_year,这里的参数实际是隐含的this指针.
            _month=month;
            _day=day;
        }
    	void Print()
        {
            cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
        }
    private:
	 int _year;
     int _month;
     int _day;
}
int main()
{
	Date d1,d2;
    d1.Init(2021,4,7);
    d2.Init(2022,4,7);
    d1.Print();
    d2.Print();
}

上述的Print()函数调用的过程实际是怎么样的？

由对象的存储模型可得，对象内部是没有存函数指针的，函数是存在公共代码段的。这里其实是有一个隐含的this指针。

实际上Print()函数被编译器处理成Print(Data* const this)。而调用的d1.Print()实际是d1.Print(&d1)。

因此达到了想要的目的。

同理，Init(int year,int month,int day)其实也会被处理成Init(Date* const this,int year,int month,int day)。其调用也就是d2.Init(&d2,2022,4,7)。

那么我们能不能显式对this写形参和实参呢？

  • 调用成员函数时不能显式地传实参给this。

  • 定义成员函数时，也不能显式声明this。

  • 因为this隐藏了，这么做是为了简洁。

*我们可以在成员函数内部可以显式地写this。模拟STL中存在return this的情况。

#include<iostream>
using namespace std;
class Date
{
    public:
    	void Init(int year,int month,int day)
        {
            //c++要用必须要先声明。但是这里却没有
            _year=year;//这里凭空访问_year,这里的参数实际是隐含的this指针.
            _month=month;
            _day=day;
        }
     	//void Init(Data* const this,int year,int month,int day)
    	//this->_year=year;
    	void P()
        {
            cout<<_year<<"-"<<_month<<"-"<<_day<<endl;
        }
    	//编译器处理后实际代码
    	void P(Date* const this)
        {
            cout<<this->_year<<"-"<<this->_month<<"-"<<this->_day<<endl;
        }
    private:
	 int _year;
     int _month;
     int _day;
}
int main()
{
	Date d1;
    d1.Init(2020,4,7);
    //d1.Init(&d1,2020,4,7);
    d1.P();
    //编译器实际
    d1.P(&d1);
}

8.2面试题

  • this指针存在哪里？进程地址空间哪个区域。

    • 存在栈区。因为他是一个形参。
    • VS下是在ECX这个寄存器里。（编译器的优化）
      • lea ecx，[d1]；

  • 下面代码引发的结果是A.编译不过 B.运行崩溃 C.正常

    • 运行正常

      class A
{
    public:
    	void Show()
        {
			cout<<"Show()"<<endl;
        }
   	private:
    	int _a;
}
int main()
{
    A* p=nullptr;
    p->Show();
}

  • 运行错误

class A
{
    public:
    	void Print()
        {
            cout<<_a<<endl;
        }
   	private:
    	int _a;
}
int main()
{
    A* p=nullptr;
    p->Print();
}

  • P虽然是空指针，但是p调用成员函数不会编译报错。因为完全不是语法错误。

  • p虽然是空指针，但是p调用成员函数也不会出现空指针访问。因为成员函数不存在类对象里面。因此p->func()，相当于call。

  • 这里会把p作为实参传递给隐藏的this指针。类似前面的fun*(&d1)。这里就是Print(&p)。

    • 	A a;
    a->Print(&a);
	A* p=nullptr;
	p->Print(&p);

  • 而前者没有对this进行解引用，后者对this指针进行了解引用。

小菜鸡加油
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值