• C++-类与对象(上)

    🗡CSDN主页：d1ff1cult.🗡

    🗡代码云仓库：d1ff1cult.🗡

    🗡文章栏目：数据结构专栏🗡

    一、

    auto关键字

    auto的意义：类型名字较长时使用auto来定义比较方便

    1.自动识别数据类型

    auto关键字可以自动识别数据的类型，我们可以是typeid()name.()函数来查看一个数据的类型

    1. int main()
    2. {
    3. 	int a = 0;
    4. 	int b = a;
    5. 	auto c = a;
    6. 	auto d = &a;
    7. 	auto* e = &a;
    8. 	int& f = a;
    9. 	cout << typeid(c).name() << endl;
    10. 	cout << typeid(d).name() << endl;
    11. 	cout << typeid(e).name() << endl;
    12. 	cout << typeid(f).name() << endl;
    13. 	return 0;
    14. }

    下面是运行结果

    typeid().name()函数可以输出一个数据的类型，我们auto c=a；a是int类型的，那么auto出来的c也是int类型的，auto d=&a，那么这个d的数据类型就是int *。

    上面只是auto用法的一个小小小小小的用法。

    2.auto的初始化

    auto初始化时必须在右边给个值进行初始化，不然auto无法识别数据的类型

    1. auto=x; //对auoto错误的初始化
    2.  
    3. auto x=1.0;
    4. auto x=1.22;

    需要注意的是auto不能作为函数的参数，也不能作为一个函数的返回值，与此同时auto也不能用来声明数组

    3.auto简化for循环

    1. int main()
    2. {
    3. int array[] = { 1,2,3,4,5 };
    4. 	for (int i = 0; i < sizeof(array) / sizeof(array[0]); i++)
    5. 	{
    6. 		array[i] *= 2;
    7. 	}
    8. 	for (int* p = array; p < array + sizeof(array) / sizeof(array[0]); ++p)
    9. 	{
    10. 		cout << *p << endl;
    11. 	}
    12. 	for (auto e : array)
    13. 	{
    14. 		cout << e << "";
    15. 	}
    16. 	cout << endl;
    17. 	return 0;
    18. }

    auto在这里的作用：依次取数组中的数字赋值给e，并且自动判断结束，自动++往后走。

    auto简化for循环时 auto e中的e只是数组内容的一份临时拷贝，对e进行操作不会修改数组中的值，如下

    1. int main()
    2. {
    3. for (auto e : array)
    4. 	{
    5. 		e++;
    6. 		cout << e << "";
    7. 	}
    8. 	cout << endl;
    9. 	for (auto e : array)
    10. 	{
    11. 		cout << e << "";
    12.  
    13. 	}
    14. 	cout << endl;
    15. 	return 0;
    16. }

    如果想要通过修改e来对数组内容进行修改，可以使用 引用

    1. int main()
    2. {
    3. for (auto &e : array)
    4. 	{
    5. 		e++;
    6. 		cout << e << "";
    7. 	}
    8. 	cout << endl;
    9. 	for (auto e : array)
    10. 	{
    11. 		cout << e << "";
    12.  
    13. 	}
    14. 	cout << endl;
    15. 	return 0;
    16. }

    eg：c语言为了效率，数组是不能够传参的，一般是使用数组的首元素的地址进行传参的。

    nullptr的使用

    c语言中的NULL本质上是一个宏定义，#define NULL 0

    在c++中 为了弥补这一缺陷，使用了nullptr来替换NULL

    二、类与对象

    1.c++中类的定义

    1. class className
    2. {
    3. // 类体：由成员函数和成员变量组成
    4. };  // 一定要注意后面的分号

    class 为定义类的关键字，ClassName 为类的名字，{} 中为类的主体，注意类定义结束时后面分 号不能省略。

    类体中内容称为类的成员：类中的变量称为类的属性或成员变量; 类中的函数称为类的方法或者成员函数。

    类的两种定义方式：

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

    1. //定义一个人
    2. class People
    3. {
    4. public:
    5. 	void show()
    6. 	{
    7. 		cout << _name << "-" << _sex << "-" << _age << endl;
    8. 	}
    9. public:
    10. 	char* _name; //姓名
    11. 	char* _sex;  //性别
    12. 	int _age;    //年龄
    13. };

    2，类声明放在 .h 文件中，成员函数定义放在 .cpp 文件中，注意：成员函数名前需要加类名::    以此来进入对应的域中

    1. People.h
    2.  
    3. //人
    4. class People
    5. {
    6. public:
    7. 	void show();
    8. public:
    9. 	char* _name; //姓名
    10. 	char* _sex;  //性别
    11. 	int _age;    //年龄
    12. };
    13.  
    14. People.cpp
    15.  
    16.  
    17. void Person::show()
    18. {
    19. 	cout << _name << "-" << _sex << "-" << _age << endl;
    20. }

    2.c语言与c++的比较

    c++向下兼容所有c语言struct所有的用法

    struct同时升级成了类

    1、类名就是类型，Stack就是类型，不需要加struct

    2、函数的定义都放在了类中

    下面这一段是c语言对栈进行初始化

    1. //C语言
    2. struct Stack
    3. {
    4.  int* a;
    5.  int top;
    6.  int capacity;
    7. };
    8.  
    9. void StackInit(struct Stack* ps);
    10. void StackPush(struct Stack* ps, int x);

     下面是c++的一段

    1. class Stack
    2. {
    3. private:
    4. 	int* a;
    5. 	int top;
    6. 	int capacity;
    7.  
    8. public:
    9. 	void Init()
    10. 	{
    11. 		a = 0;
    12. 		top = 0;
    13. 		capacity = 0;
    14. 	}
    15.  
    16. 	void Push(int x)
    17. 	{
    18. 		//...
    19. 	}
    20.  
    21. 	bool Empty()
    22. 	{
    23. 		return top == 0;
    24. 	}
    25. };

     同样都是对栈进行声明以及初始化，但其实c++是比较方便简单的，例如Push()函数，c语言是不支持重名函数的，但是在c++中不同的域中函数的作用不同，我们可以通过调用不同的域中的函数来实现不同的功能

    3.类的访问限定符以及封装

    3.1访问限定符

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

    1.public修饰的成员在类外可以直接被访问
    2. protected和private修饰的成员在类外不能直接被访问(此处protected和private是类似的)

    3.访问权限作用域从该访问限定符出现的位置开始直到下一个访问限定符出现时为止

    4.如果后面没有访问限定符，作用域就到 }，即类结束
    5.class的默认访问权限为private，struct为public(因为struct要兼容C)

    这里有一道关于struct和class的面试题：

    C++ 中 struct 和 class 的区别是什么？

    C++ 需要兼容 C语言，所以C++中struct可以当成结构体使用；

    另外C++中struct还可以用来定义类。和class定义类是一样的，区别是struct定义的类默认访问权限是public，class定义的 默认访问权限是private；

    3.2封装

    • 封装可以隐藏实现细节，使得代码模块化，使代码和功能独立
    • 封装是把函数和数据包围起来，对数据的访问只能通过可信任的对象和类进行访问，对不可信的进行信息隐藏。
    • 封装本质上是一种管理，让用户更方便使用类。

    3.3类的作用域

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

    1. class Person
    2. {
    3. public:
    4. 	void PrintPersonInfo();
    5. private:
    6. 	char _name[20];
    7. 	char _gender[3];
    8. 	int  _age;
    9. };
    10. // 这里需要指定PrintPersonInfo是属于Person这个类域
    11. void Person::PrintPersonInfo()
    12. {
    13. 	cout << _name << " " << _gender << " " << _age << endl;
    14. }

     访问时如果不加作用域操作符号，编译器就不知道应该调用哪一个域内的函数。

    c++中花括号定义的都是域

    3.4类的声明与定义分离

     类中成员函数可以在类中直接进行声明与定义同时也可以将声明和定义分开，例如下面

    在类中定义时，由于我们已经在对应的域中，所以我们不需要使用::访问，若我们将成员函数的声明与定义分离之后，定义的时候就需要加上这样使用：void Stack::Init()，因为我们不知道这个Init函数究竟是哪一个类中的成员，所以我们需要使用::来限制它的域

    1. //Stack.h文件
    2. class Stack
    3. {
    4. private:
    5. 	int* a;
    6. 	int top;
    7. 	int capacity;
    8. public:
    9. 	void Init();
    10. 	void Push(int x);
    11. 	bool Empty();
    12. };
    13. //Stack.cpp文件
    14. void Stack::Init()
    15. {
    16. 	a = 0;
    17. 	top = 0;
    18. 	capacity = 0;
    19. }
    20. void Stack::Push(int x)
    21. {
    22. 	//....
    23. }

    在类中定义的函数默认就是inline，正确的定义方法应该是，长的函数的定义和声明分离，短小的可以直接在类里面定义

     3.5成员变量命名规则

    1. class Date
    2. {
    3. public:
    4. 	void Init(int year)
    5. 	{
    6. 		year = year;
    7. 	}
    8. private:
    9. 	string year;
    10. };
    11.  
    12. int main()
    13. {
    14. 	return 0;
    15. }

    看到这个函数我们不免发出疑问，调用Init的这个函数中 两个year，哪一个是成员变量，哪一个是函数的形参，这样的写法使得阅读代码的人一个头两个大。所以我们可以在成员变量前加上一个下划线来区分形参和成员变量

    1. class Date
    2. {
    3. public:
    4. 	void Init(int year)
    5. 	{
    6. 		_year = year;
    7. 	}
    8. private:
    9. 	int _year;
    10. };

     3.6内存对齐规则

    1，第一个成员在与结构体偏移量为 0 的地址处。

    2，其他成员变量要对齐到某个数字（对齐数）的整数倍的地址处。

         注意：对齐数 = 编译器默认的一个对齐数 与 该成员大小的较小值。

         VS中默认的对齐数为8

    3，结构体总大小为：最大对齐数（所有变量类型最大者与默认对齐参数取最小）的整数倍

    4，如果嵌套了结构体的情况，嵌套的结构体对齐到自己的最大对齐数的整数倍处，结构体    的整体大小就是所有最大对齐数（含嵌套结构体的对齐数）的整数倍。

     3.7类中对象的存储方式

    存储方式：保留成员变量，成员函数存放在公共的代码段

     类的大小，根据内存对齐规则可以求得

    需要注意的是：一个类的大小就是通过内存对齐规则后求得的大小，特殊的是我们要注意空类的大小，空类比较特殊，编译器给了空类一个字节来唯一标识这个类的对象。

    1. class Date
    2. {
    3. public:
    4. 	void Init(int year, int month, int day)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10.  
    11. //private:
    12. 	// 声明
    13. 	int _year;
    14. 	int _month;
    15. 	int _day;
    16. };
    17.  
    18. class A
    19. {
    20. private:
    21. 	char _ch;
    22. 	int _a;
    23. };
    24.  
    25. class B
    26. {};
    27.  
    28. class C
    29. {
    30. public:
    31. 	void f()
    32. 	{};
    33. };
    34. int main()
    35. {
    36. 	Date d1;
    37. 	Date d2;
    38. 	Date d3;
    39.  
    40. 	cout << sizeof(d1) << endl;
    41. 	cout << sizeof(A) << endl;
    42.  
    43. 	B b1;
    44. 	B b2;
    45.  
    46. 	cout << sizeof(B) << endl;
    47. 	cout << sizeof(C) << endl;
    48.  
    49. 	// 无成员变量的类，对象大小开一个字节，这个字节不存储有效数据
    50. 	// 标识定义的对象存在过
    51.  
    52. 	return 0;
    53. }

     

    类B与类C的大小都是1。

    3.8 this指针

    我们先来看下面这样一段代码

    1. class Date
    2. {
    3. public:
    4. 	void Init(int year, int month, int day)
    5. 	{
    6. 		_year = year;
    7. 		_month = month;
    8. 		_day = day;
    9. 	}
    10. 	void Print()
    11. 	{
    12. 		cout << _year << "-" << _month << "-" << _day << endl;
    13. 	}
    14. private:
    15. 	int _year;     // 年
    16. 	int _month;    // 月
    17. 	int _day;      // 日
    18. };
    19. int main()
    20. {
    21. 	Date d1, d2;
    22. 	d1.Init(2022, 1, 11);
    23. 	d2.Init(2023, 1, 12);
    24. 	d1.Print();
    25. 	d2.Print();
    26. 	return 0;
    27. }

     

    d1.Print()没有传参数，为什么还能打印出d1的内容呢，这一切都要归功于this指针

    C++ 编译器给每个“非静态的成员函数“增加了一个隐藏的指针参数，让该指针指向当前对象(函数运行时调用该函数的对象)，在函数体中所有“成员变量” 的操作，都是通过该指针去访问。只不过所有的操作对用户是透明的，即用户不需要来传递，编译器自动完成。

     3.9this指针的一些性质

    1.this指针的类型是const *类型，不能写this相关的实参和形参，不能给this指针赋值

    2.只能在成员函数内部使用

    3.this指针能在类中显示调用

    4.this指针是个形参，存储在栈帧上，不是存储在对象中的

    总结

  • 相关阅读:
    [附源码]SSM计算机毕业设计医院挂号系统JAVA
    赠人玫瑰，手有余香，分享5款精致小巧的软件
    Go Machine Learning
    python实现命令tree的效果
    DT灯光基础（辉光 雾 阴影 渲染选项）
    [附源码]计算机毕业设计校园快递柜存取件系统Springboot程序
    Java2-3年面试题
    在应用内维护域名缓存时遇到的问题
    数据库与redis缓存一致性问题
    使用命令进行把新代码上传到git上
  • 原文地址：https://blog.csdn.net/qq_74732628/article/details/134082663