c++ 基础知识,c++相关知识

　　博客明星评选

　　我不能在它面前写字。我有点激动。真的不容易。可以说，一旦我们了解了类，我们的知识就可以提高到一个更高的层次。类是我们面向对象的基础。我现在无法表达我对他们的感受。这个博客主要是先了解一下阶级。至于细节，下面的博客会详细分享。算了，我们起航吧。

　　类类和对象是学习面向对象语言的基础，太重要了。

　　什么是阶级？我们先来看定义。很花哨。

　　Class(英文：Class)是面向对象编程中一种面向对象的计算机编程语言的构造。它是创建对象的蓝图，描述了所创建对象的共同特征和方法。

　　支持类的编程语言在支持与类相关的各种特性方面有一些微妙的区别。他们大多持有不同形式的类继承。许多语言也支持提供封装的特性，比如访问修饰符。类的出现为实现面向对象编程的三个最重要的特征(封装、继承和多态)提供了手段。来源：(维基百科)

　　用人类的话来说，我们把一些变量和函数放到一个集合里，这个集合有一定的规则，叫做类。稍后，我们可以通过类实例化对象，我们将在后面分享。

　　为什么要上课？我们之前学习数据结构的时候，定义了结构和函数是分离的。这种行为有一定的缺陷，过于自由，于是聪明的程序员想到了是否可以把这些方法和要用的变量一起写出来，用的时候拿出来就好了。这就是阶级的起源。

　　如何定义一个类，可以这么理解。某种程度上，C是为了填补C语言中的一些漏洞。我们学过C语言的结构，但是里面只能定义变量，C可以定义一些函数，所以这个结构就演变成了类。

　　下面是一节课。

　　结构人

　　{

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　int _ age

　　char _ name[20]；

　　};也就是说，一个类就是给一个结构增加一些功能。

　　但是，在C中定义类时，会出现另一个关键字calss。至于它和strcut的区别，后面再说。

　　阶级人士

　　{

　　};什么是对象？在计算机科学中，一个object(英文：object)，台湾省翻译为‘object’，就是一个内存地址，里面有一个值。这个地址可能有一个指向它的标识符。对象可以是变量、数据结构或函数。是面向对象中的一个术语，它不仅表示客观世界的问题空间中的一个具体事物，也表示软件系统的解空间中的基本元素。

　　在软件系统中，对象有唯一的标识符，包括属性和方法。属性是需要记忆的信息，方法是对象可以提供的服务。在面向对象的软件中，对象是一个类的实例。来源：维基百科

　　总结句子如下

　　一个班就是一个模子。我们按照这个模子造东西。对象是一个实体。我们通过模具构造的实体实例化一个对象。在C中，类名本身可以表示一个类型。不需要加入struct，但是可以加入struct。

　　int main()

　　{

　　结构人员人员1；

　　个人个人2；//你可以去掉struct

　　返回0；

　　class}的构成前面我们已经初步了解了class，这是今天的亮点。我们需要一点解剖学知识。

　　结构人

　　{

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　int _ age

　　char _ name[20]；

　　};类的构成分为以下两种。

　　有时字段也称为成员变量，属性方法类中的函数称为类或成员函数字段的方法。所谓的字段就是其中的一些变量，下一篇博客会详细分享给大家。

　　int _age，char _ name[20]；是田野。

　　我们在方法中定义的函数print()和set()都是方法。C中的方法属于类，而不是对象。

　　方法在C语言中，我们一般称之为函数，但在C中，我更喜欢称之为方法，我不太明白两者的区别。我在网上找了一些，这里有个解决办法。类的内部叫方法，类的外部叫函数。别担心，都是小问题。

　　访问限定符非常重要，但是我们现在不能在这里详细讨论，但是不要担心。

　　可以在共享的公共类外使用private private，在类内使用受保护的继承时只能说class Person。

　　{

　　公共：

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　私人：

　　int _ age

　　char _ name[20]；

　　};所谓的访问修饰符就是权限的问题，这里就不赘述了。

　　修改访问限定符的范围访问权限的范围从访问限定符出现的位置开始，直到下一个访问限定符出现，这样就避免了多次使用同一个限定符的麻烦。

　　类struct既然struct和calss都可以定义类，那么两者有什么区别呢？首先要明白，C中常用class，两者没有太大区别。如果没有访问修饰符，默认情况下calss中的方法和属性都是私有的，而默认情况下是共享的。

　　C需要兼容C语言，所以C中的struct可以作为结构使用。另外，C中的struct也可以用来定义类。

　　类与定义类相同，只是struct成员的默认访问模式是public，而类成员的默认访问模式是。

　　私人.

　　阶级人士

　　{

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　私人：

　　int _ age

　　char _ name[20]；

　　};

　　结构学生

　　{

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　私人：

　　int _ age

　　char _ name[20]；

　　};

　　int main()

　　{

　　//类创建

　　Person人；

　　person.set(qkj ，18)；

　　person . print()；

　　//结构创建

　　学生学生；

　　student.set(战三，19)；

　　student . print()；

　　返回0；

　　}

　　我们知道如何计算一个结构的大小，那么一个类的大小是怎么计算的呢？我们应该把函数当作指针吗？还是不做计算？

　　先看现象。

　　从这里可以看出，我们不计算函数的大小，只计算属性。类的计算方法和结构一样，也遵循内存对齐。

　　班级学生

　　{

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　私人：

　　int _ age

　　char _ name[20]；

　　};

　　int main()

　　{

　　cout sizeof(学生)endl

　　返回0；

　　}

　　为什么不计算方法的内存？如果我们计算函数的大小，就意味着我们每实例化一个对象，就需要为这个函数腾出空间。如果我们实例化太多对象，内存会不会被打开得太快？所以一个类中的方法只会创建一个空间，而且这个类无论实例化多少次，方法都只会创建一次，所以这个方法的空间计算会有一些争议，所以不计算。

　　int main()

　　{

　　学生stu1

　　stu1.set(qkj ，18)；

　　学生stu2

　　stu2.set(qkj ，18)；

　　返回0；

　　}

　　空类我们知道如何计算类的大小，那么下面的类的大小是多少呢？它是一个空类，它的大小应该是0吗？其实不是的。编译器给它一个1字节的大小，作为占位符告诉编译器有这样一个类。

　　B类

　　{

　　};

　　一节课什么时候打开空间？在这里，我们需要讨论一下。当我们实例化一个对象时，开放空间就会出现。存在于类中的属性是一个声明，它没有打开空间。

　　int main()

　　{

　　学生stu1

　　stu1.set(qkj ，18)；

　　返回0；

　　}

　　这个指针告诉我们，既然方法不属于对象，而是属于类，编译器如何确定对象调用的方法一定是正确的？

　　编译器如何确保对象可以调用正确的方法？

　　代码运行时，编译器会自动将对象的地址作为参数传递给函数，这样就可以准确地调用函数。这是编译器的自动处理，我们不能显示处理，很快就会抢了编译器的工作！

　　阶级人士

　　{

　　公共：

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

　　私人：

　　int _ age

　　char _ name[20]；

　　};

　　int main()

　　{

　　Person per1

　　1.per1.set(张三，18)；

　　Person per2

　　Per2.set(《李四》，20)；

　　per 1 . print()；

　　per 2 . print()；

　　返回0；

　　}

　　实际上，编译器会在函数被调用时对其进行优化。我先写给你，你一眼就能看出来。

　　作废打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　//编译器默认如下

　　作废打印(人* const this)

　　{

　　Cout 我叫 this- _name ，今年 this- _age 岁；

　　cout endl

　　}

　　前面我们看到过这个关键字，它表示对象中当前对象的地址。

　　A级

　　{

　　公共：

　　作废打印()

　　{

　　cout“this”this endl；

　　}

　　};

　　int main()

　　{

　　A a

　　a . print()；

　　cout a a endl

　　返回0；

　　}

　　也就是说我们之前可以这样写打印函数，但是我不推荐。既然编译器已经给我们做了，我们就不需要了，但是要看我们公司的代码规范要求。

　　作废打印()

　　{

　　Cout 我叫 this- _name ，今年 this- _age 岁；

　　cout endl

　　}这个指针的类型：class type * const只能用在“成员函数”内部。本质上，这个指针实际上是一个成员函数的参数。当对象调用成员函数时，它将对象的地址作为参数传递给此参数。所以这个指针没有存储在对象中。

　　* *该指针是成员函数的第一个隐式指针参数，通常由编译器通过ecx寄存器自动传递，不需要用户传递* *

　　这个指针存在于哪里？由于这个指针是作为参数使用的，所以存储在堆栈区，但是有些编译器会对它进行优化，存储在寄存器中。

　　这个指针可以是空的吗？可以是空的。

　　B类

　　{

　　公共：

　　作废打印()

　　{

　　cout这个endl

　　}

　　};

　　int main()

　　{

　　B * b=nullptr

　　b-print()；

　　返回0；

　　}

　　在多个文件中使用类和文件是编写大型程序的基础。我们需要使用类。我们需要谈谈这件事。我们可以在类体中声明和定义方法，但是如果成员函数是在类中定义的，编译器可能会将它们视为内联函数。

　　一般我们在头文件中声明类，在类中声明属性和方法，方法的实现在另一个文件中。我们通常这样做。

　　//test.h

　　#包括iostream

　　使用命名空间std

　　阶级人士

　　{

　　void打印()；

　　void set(const char* name，int age)；

　　int _ age

　　char _ name[20]；

　　};

　　//test.cpp

　　#包含“test.h”

　　作废人：打印()

　　{

　　Cout 我叫 _name ，今年 _age 岁；

　　cout endl

　　}

　　void Person:set(const char* name，int age)

　　{

　　_age=年龄；

　　strcpy(_name，name)；

　　}

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。