【探索C++】三大特性以及类和对象（包括类的特殊函数成员）

最新推荐文章于 2024-11-02 20:20:37 发布
最新推荐文章于 2024-11-02 20:20:37 发布
阅读量367 收藏 5
点赞数 4
分类专栏： 探索C++编程 文章标签： c++ 开发语言 服务器 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64928278/article/details/133096294
版权

【探索C++】用实例教你理解面向对象编程（看不懂打我版）_祐言QAQ的博客-CSDN博客

        之前写过一篇用最通俗的方法理解面向对象编程思想（链接如上），是对OOP的一种通俗易懂的理解，但这其中还有很多奥秘是一篇简单的举例讲不清的，今天我们就来认真学习一下类和对象中几乎所有的知识点，让你彻底理解C++到底在讲什么鬼。当然，个人拙见，还希望大神在我说错的地方加以指正。

一、编程范式

        在学习C++的三大特性以及类和对象的具体使用和区别之前我们先来了解一下编程范式，它是软件开发中的基本思维模式，常见的有面向过程和面向对象两种范式。下面将一下介绍这两种范式的主要特点以及面向对象程序设计的核心概念。

1. 面向过程

  • 以函数或过程为中心的编程思想。
  • 代表语言：C语言。
  • 问题解决的重点在于逻辑流程，先定义问题的逻辑步骤，然后编写相应的函数来实现这些步骤。
  • 设计过程通常是先考虑问题的逻辑，然后在此基础上进行抽象。

2. 面向对象

  • 以对象为中心的编程思想。
  • 代表语言：C++、Java、C#等。
  • 问题解决的重点在于对象，每个对象有自己的属性和方法。
  • 强调将数据和方法封装在类中，以隐藏内部实现细节，提供清晰的接口。

3. 面向对象程序设计的核心概念

1. 类和对象

        类：定义对象的蓝图或模板，包括数据成员和成员函数。

        对象：类的实例，包含了类定义的属性和可以执行的方法。

        封装：将数据和方法封装在类中，以隐藏内部实现细节，提供清晰的接口。

2. 继承和派生

        继承：允许一个类（子类）继承另一个类（父类）的属性和方法。

                   子类可以重用父类的代码，同时可以添加新的成员或修改继承的成员。

        派生：子类从父类继承属性和方法的过程。

3. 多态

        多态：允许不同的对象对相同的消息或方法调用作出不同的响应。

                   多态性使得代码可以更灵活，能够适应不同类型的对象。

                   多态通常通过虚函数和函数重载实现。

        在面向对象程序设计的核心概念里，我们不难发现其真正的核心就是C++的三大特性：封装，继承和多态，那么他们到底是什么呢，接下来我们将其逐一分开解析，争取让你能在这一篇文章中理解C++的精髓所在。

二、抽象和封装

        在面向对象编程中，抽象和封装是两个关键概念，它们有助于有效地设计和组织代码。

2.1 抽象

        抽象是指对具体对象（事物）进行概括，提取出这一类对象的公共性质以进行描述。在面向对象编程中，抽象可以分为两种主要类型：

        (1) 数据抽象（性质抽象）

        数据抽象描述了某类对象的属性或状态，这些属性通常是对象之间的区别所在，它们形成了数据成员。以汽车为例，数据抽象可以包括：

  • 车的颜色
  • 车的窗户数量
  • 车的门数量
  • 其他与车辆属性相关的信息

        这些数据成员用于表示汽车对象的属性。

        (2) 方法抽象（行为抽象）

        方法抽象描述了某类对象的公共行为或具备的功能，这些行为通常被形成为方法成员（也就是函数成员）。以汽车为例，方法抽象可以包括：

  • 开车
  • 倒车
  • 转弯
  • 其他与车辆行为相关的操作

        这些方法成员定义了汽车对象可以执行的操作或行为。

        抽象有助于将现实世界的事物映射到代码中，使我们能够更好地理解和处理问题领域。它是面向对象程序设计中的关键概念之一。

2.2 封装

        封装是将数据和相关操作封装在一个单元（通常是一个类）内部的过程，以隐藏实现细节，并提供清晰的接口供外部使用。封装有以下优点：

  • 数据隐藏：数据成员可以被声明为私有，从而防止直接访问和修改，提高了数据的安全性和完整性。
  • 接口定义：通过公共成员函数来操作数据，为外部提供了一个清晰的接口，降低了使用代码的复杂度。
  • 实现隔离：封装允许类的内部实现细节发生变化，而不会影响外部代码，提高了代码的灵活性和可维护性。

        封装是面向对象编程中的核心概念之一，有助于构建模块化和可扩展的代码。

三、类（class）

3.1 概念

        类 是面向对象编程中的关键概念，它抽象出具有相同特性（数据成员）和行为（函数成员）的对象。对象是类的实例化。

3.2 基本语法

类的声明：

class 类名
{
public:
                    // 类的公有数据成员和方法成员

protected:
                    // 类的保护数据成员和方法成员

private:
                    // 类的私有数据成员和方法成员
};

注意事项：

  • 类名一般首字母大写。
  • 类的成员默认访问权限是私有（private）。
  • 类的成员访问权限包括：公有（public）、保护（protected）和私有（private）。
    • public：允许在外部直接通过类的对象访问。
    • protected：不允许在外部直接通过类的对象访问，只能在类内部进行访问，可以通过类内部的公有接口访问。
    • private：不允许在外部直接通过类的对象访问，只能在类内部进行访问，可以通过类内部的公有接口访问。

3.3 类的成员函数实现

        类的成员函数可以在类内部或外部进行实现。

        （1）内部实现：

class A 
{
public:
    // 成员函数内部实现，可以访问私有成员x
    void set_x(int x1)
    {
        x = x1;
    }

private:
    int x;
};

        （2）外部实现：

class A 
{
public:
    // 成员函数外部实现，声明在类内部，定义在外部
    int get_x();

private:
    int x;
};

// 成员函数的外部定义
int A::get_x()
{
    return x;
}

        当然在内部实现时可行且简便的，但是如果一个方法函数很长，也就是功能很复杂时，我们将其定义在类内是一种及其不合理的做法，因此一般开发都是将成员函数（方法函数）写在类外实现的，这样不仅美观，修改起来也更方便。

四、对象（Object）

        对象 是类的实例化，它包含了类定义的属性和可以执行的方法。在面向对象编程中，对象是操作和交互的主要实体。

4.1 定义对象

        （1）直接定义对象

        要定义一个类的对象，只需使用该类的名称和对象名称即可。

// 定义一个名为person的Person类对象
Person person;
        （2）使用指针定义对象

        你也可以使用指针来定义类的对象，这通常与动态内存分配相关。

// 使用指针定义Person类对象
Person* personPtr = new Person;

4.2 通过类的对象访问成员

        (1) 访问公有成员

        通过对象名，你可以直接访问类的公有成员变量和方法。

// 访问公有成员变量
person.name = "Alice";
int age = person.age;

// 调用公有成员方法
person.displayInfo();

        如果你有一个指向对象的指针，可以使用箭头运算符（->）来访问对象的公有成员。

// 使用指针访问公有成员变量
personPtr->name = "Bob";
int age = personPtr->age;

// 使用指针调用公有成员方法
personPtr->displayInfo();

        (2) 访问非公有成员

        非公有成员通常无法直接访问，必须通过公有函数（公开接口函数）进行访问。这种方式保证了封装性和数据的安全性。

// 在类的公有函数中访问非公有成员
class Person {
public:
    // 公有函数用于访问私有成员name
    void setName(const std::string& newName) {
        name = newName;
    }

    // 公有函数用于获取私有成员name
    std::string getName() {
        return name;
    }

private:
    std::string name;
};

 4.3  示例

        巴巴一大堆了，演示一个实例吧：设计一个简单的关于类的程序，定义一个点类（Point），包含x,y坐标（私有成员）,该类包含以下功能：

        （1）设置X坐标，（公有成员，在内部实现）；

        （2）设置Y坐标，（公有成员，在外部实现）；

        （3）得到X坐标，（保护成员，在内部实现）；

        （4）得到Y坐标，（保护成员，在外部实现）；

        （5）最终显示坐标（10，13）（私有成员，在外部实现）；

        代码：

#include <iostream>

using namespace std;

class Point 
{
public:
    // 设置X坐标，在内部实现
    void set_x(int x1)
    {
        x = x1;
    }

    // 设置Y坐标，在外部实现
    void set_y(int y1);
	
	int get_x_value()
	{
		return get_x();
	}
	
	int get_y_value()
	{
		return get_y();
	}
	void show()
	{
		show_xy();
	}

protected:
    // 得到X坐标，在内部实现
    int get_x() 
    {
        return x;
    }
	int get_y();

private:
    int x;
    int y;
	void show_xy();
};

// 设置Y坐标，在外部实现
void Point::set_y(int y1)
{
    y = y1;
}
// 得到y坐标，外部
int Point::get_y()	
{
	return y;
}
// 显示函数，外部
void Point::show_xy()
{
	cout << "(" << get_x_value() << "," << get_y_value() << ")" << endl;
}

int main(int argc, char const *argv[])
{
    Point a;
    int x1 = 0;
    int y1 = 0;

    cout << "输入 X 坐标：" << endl;
    cin >> x1;
    a.set_x(x1);

    cout << "输入 Y 坐标：" << endl;
    cin >> y1;
    a.set_y(y1);

	a.show();
	// cout << "(" << get_x_value() << "," << get_y_value() << ")" << endl;
    return 0;
}

        这是一个平平无奇的简单例子，但它却用到了上述几乎所有知识点，如果你能完全看懂并理解，那么我想你的前途无量啊！哈哈哈~

五、类的特殊函数成员

        在面向对象编程中，类可以拥有特殊的函数成员，包括构造函数、析构函数和拷贝构造函数。这些函数在对象的创建、销毁和复制过程中发挥重要作用。

5.1 构造函数

class MyClass {
public:
    // 构造函数的声明
    MyClass(); // 默认构造函数，无参数

    // 构造函数的定义
    MyClass() {
        // 在构造函数中初始化数据成员
        // 这里可以添加初始化操作
    }

private:
    // 数据成员
    int data;
};

// 构造函数的实现
MyClass::MyClass() {
    // 在构造函数中初始化数据成员
    // 这里可以添加初始化操作
}

        构造函数用于在实例化对象时初始化对象的数据成员。构造函数具有以下特点：

  • 构造函数的名称必须与类名相同。
  • 构造函数没有返回值，包括不带返回类型（void）。
  • 默认情况下，每个类都有一个默认构造函数，如果没有自己编写构造函数，系统会自动生成一个空的默认构造函数。
  • 构造函数必须是公有的（public）。

        （1）关于构造函数的重载和默认参数：

        构造函数可以重载，允许多个构造函数根据参数不同进行选择。构造函数还可以带有默认参数，但在多个构造函数重载的情况下，要慎用默认参数，以免造成歧义。

        （2）关于构造函数的初始化列表：

        构造函数可以使用初始化列表的方式来初始化成员变量，这样可以提高效率，特别是在处理类的成员变量是对象类型或常量时。

        （3） 示例代码

        设计一个基于对象的程序，来实现求长方体的体积与表面积。（提示：抽象出一个长方体类Cuboid，数据成员包括：length，width，high），通过构造函数实现数据成员的初始化。要求：

1、有键盘输入长方体的长宽高；

2、计算长方体的体积（公有函数）；

3、显示长方体长宽高跟体积、表面积（公有函数）。

#include <iostream>

using namespace std;

class Cuboid
{
public:
    // 构造函数
    Cuboid(int x, int y, int z)
    {
        length = x;
        width = y;
        high = z;
    }

    void show_v()
    {
        cout << length * width * high << endl;
    }

    void show_all()
    {
        cout << "长：" << length << endl;
        cout << "宽：" << width << endl;
        cout << "高：" << high << endl;
        cout << "体积：" << length * width * high << endl;
        cout << "表面积：" << 2 * (length * width + length * high + width * high) << endl;
    }

private:
    int length;
    int width;
    int high;
	
};

int main(int argc, char const *argv[])
{

	int x, y, z;
    cout << "请输入长宽高：" << endl;
    cin >> x >> y >> z;

    Cuboid cuboid(x, y, z);

    cuboid.show_v();
    cuboid.show_all();

    return 0;
}

5.2 析构函数

class MyClass {
public:
    // 析构函数的声明
    ~MyClass();

private:
    // 数据成员
    int data1;
    double data2;
    char* data3; // 示例指针成员
};

// 析构函数的定义
MyClass::~MyClass() {
    // 在析构函数中清理资源
    // 这里可以添加资源释放操作
}

        析构函数用于在对象被销毁时清理并释放对象分配的资源和内存。析构函数具有以下特点：

  • 析构函数的名称是类名前面加上波浪号（~）。
  • 析构函数没有参数，也不能重载。
  • 如果没有定义析构函数，编译器会生成一个默认析构函数。
  • 析构函数通常用于释放特殊资源，如文件句柄、动态内存等。

示例代码：

        设计一个文件相关的类，包含一个数据成员是文件描述符，要求在构造函数里面实现指定文件的打开，在析构函数里面实现文件的关闭。

它没打开是因为我没创建，仅此而已。

#include <iostream>

extern "C"
{
	#include <sys/types.h>
	#include <sys/stat.h>
	#include <fcntl.h>
	#include <unistd.h>
}


using namespace std;

class File
{
public:
	File(string filename)
	{
		cout << "这是构造函数" << endl;
		fd = open(filename.c_str(), O_RDWR);
		if (fd == -1)
		{
			cout << "文件打开失败" << endl;
		}
		else
		{
			cout << "文件打开成功" << endl;
		}
	}
	~File()
	{
		cout << "这是析构函数" << endl;
		close(fd);
	}

private:
	int fd;

};

int main(int argc, char const *argv[])
{
	string filename;
	cin >> filename;

	File f(filename);
	File f1(f);		//拷贝构造函数

	return 0;
}

5.3 拷贝构造函数

class MyClass {
public:
    // 拷贝构造函数的声明
    MyClass(const MyClass& other);

private:
    // 数据成员
    int data1;
    double data2;
    char* data3; // 示例指针成员
};

// 拷贝构造函数的定义
MyClass::MyClass(const MyClass& other) {
    // 在拷贝构造函数中复制其他对象的值
    // 这里可以根据需要实现复制逻辑
}

        拷贝构造函数用于将一个对象的值复制到另一个新构造的对象。拷贝构造函数具有以下特点：

  • 拷贝构造函数的参数是对同类对象的常引用（const 类名& 对象名）。
  • 拷贝构造函数可以自定义，但如果没有自定义，编译器会生成一个默认的拷贝构造函数。
  • 自定义拷贝构造函数通常用于处理类中特殊资源的复制。
        （1）为什么要加 const ？

        保证在拷贝过程中不会修改原对象；

        const不能转非const，此处加const可以满足两种。

        （2）为什么要用引用 ？

        如果不加引用，那么在调用拷贝构造函数的时候，实参给形参赋值这个又是一个拷贝过程，这个过程就会一直递归下去。

        （3）什么时候会调用拷贝构造函数

语法：
类名(const 类名 &对象名)
{
    //代码块;
}

示例：
A(const A &a)
{
    cout << "拷贝构造函数" << endl;
    ax = a.ax;
}

        ① 类对象的赋值运算：A a3 = a1；

        ② 用一个对象去构造另外一个对象的时候：A a2(a1)；

        ③ 类的对象作为函数返回的时候，也会调用拷贝构造函数；

        ④ 类的对象作为函数形参的时候，在函数调用过程中也会发生拷贝构造函数的调用。

注意：

        ① 类的对象的引用作为函数返回的时候，不会调用拷贝构造函数；

        ② 类的对象的引用作为函数形参的时候，在函数调用过程中不会发生拷贝构造函数的调用。

        （4）什么时候需要自定义拷贝构造函数？

        当类持有其他特殊资源（比如指针）的时候，不能用默认拷贝构造函数，要自定义拷贝构造函数：

        ① 在构造过程中有文件相关操作的时候；

        ② 动态内存空间（堆空间）；

        ③ 网络连接相关的操作；

        ④ 指针指向一些其他特殊资源。

（5）深拷贝和浅拷贝

        ① 默认拷贝构造函数，属于浅拷贝，直接做值的一个赋值，不会去考虑空间的一个申请。

        浅拷贝的坏处就是在有特殊成员的时候，直接赋值地址，导致在析构函数释放空间的时候，造成二次释放，报double free这个错误。

class A
{
public:

    
    A(int a, int b)
    {
        cout << "构造函数" << endl;
        ax = a;
        ay = new int(b);
    }
    ~A()
    {
        cout << "析构函数" << endl;    
        delete ay;
    }
    //拷贝构造函数
    A(const A &a)    //这种拷贝方式跟来里面默认拷贝方式一样的，直接赋值，浅拷贝
    {
         cout << "拷贝构造函数" << endl;
         ax = a.ax;
         ay = a.ay;    //地址赋值
    }
    

private:
    int ax;    
    int *ay;
};

        ② 将对象所持有的其他资源一并拷贝，并且为新对象单独分配特殊数据资源的方法就是深拷贝。

        深拷贝过后，原有对象和新的对象所持有的动态数据是相互独立的，更改一个对象的数据对另一个对象不会有影响的。

class A
{
public:
    A(){cout << "默认无参构造函数" << endl;}
    A(int a, int b)
    {
        cout << "构造函数" << endl;
        ax = a;
        ay = new int(b);
    }
    ~A()
    {
        cout << "析构函数" << endl;    
        delete ay;
    }
    //拷贝构造函数
    A(const A &a)
    {
        cout << "拷贝构造函数" << endl;
        ax = a.ax;

        
        ay = new int;    //先申请新的空间
        *ay = *a.ay;        //值传递
    }
private:
    int ax;    
    int *ay;
};

        更多C/C++语言、Linux系统、数据结构和ARM板实战相关文章，关注专栏：

   手撕C语言

            玩转linux

                    脚踢数据结构

                            系统、网络编程

                                     探索C++

                                             6818（ARM）开发板实战

📢写在最后

  • 今天的分享就到这啦~
  • 觉得博主写的还不错的烦劳 一键三连喔~
  • 🎉🎉🎉感谢关注🎉🎉🎉
祐言QAQ
关注
专栏目录
C++继承的使用
山重水复疑无路,柳暗花明又一村
10-29 303
C++继承的使用 用继承实现输出长方体面积和体积 实现代码： #include using namespace std; class Rectangle1{ public: void getWidth(int w){ width=w; } void getLength(int l){ length=l; } void get
【C++篇】C++类与对象深度解析（三）：类的默认成员函数详解
半截诗的博客~
09-18 2551
在这篇文章中，我们详细介绍了C++中的运算符重载和赋值运算符重载的概念与实现。通过逐步的代码示例，你将学习如何定义和使用这些运算符，以便自定义类对象的行为。同时，我们讨论了编译器自动生成的赋值运算符的局限性，深拷贝与浅拷贝的区别，以及在处理动态资源时显式定义赋值运算符的重要性。这篇文章是理解C++类机制的关键一步，适合所有C++初学者和需要巩固基础的开发者。
⚡【C++要笑着学】(7) 默认成员函数：构造函数 | 析构函数 | 拷贝构造函数
热门推荐
有道无术, 术尚可求。有术无道, 止于术。
03-15 3万+
朋友们好啊，今天终于更新了。我是柠檬叶子C，本章将继续讲解C++中的面向对象的知识点，本篇主要讲解默认成员函数中的构造函数、析构函数和拷贝构造函数。还是和以前一样，我们将由浅入深地去讲解，以 "初学者" 的角度去探索式地学习。会一步步地推进讲解，而不是直接把枯燥的知识点倒出来，应该会有不错的阅读体验。如果觉得不错，可以 "一键三连" 支持一下博主！
【C++类和对象】探索static成员、友元以及内部类
Renswc的博客
04-25 2907
static静态成员在一些场景下可以用来保存全局数据或提供公共的工具函数，也可以用来实现单例模式等。但需要注意，在多线程环境下操作静态成员时需要考虑线程安全性。友元关系提供了一种在需要的情况下访问其他类的私有成员的机制。但由于友元关系破坏了封装性，一般不使用。内部类是指在一个类的内部定义的另一个类。内部类可以直接访问外部类的成员，包括私有成员，而外部类则不能直接访问内部类的成员。。
【ONE·C++ || 类和对象（二）·类的六个默认成员函数】
上士闻道，勤而行之。觉纷扰则静坐，觉懒看书则且看书 ♪(´▽｀)
11-23 344
类和对象入门：默认的成员函数讲解，构造函数、析构函数、拷贝构造函数、赋值运算符重载、const成员函数、取地址及const取地址操作符重载。
C++ 类成员的初始化 : 探索C++成员初始化的策略与应用
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-12 538
C++ 类成员的初始化 : 探索C++成员初始化的策略与应用
【C++】探索C++中的类与对象（中）---类的8个默认成员函数
青竹雾色间.的博客
04-05 771
通过理解以上这些基本概念和常用操作，我们可以更好地设计和使用类与对象，提高代码的可维护性和可扩展性。同时，合理利用构造函数、析构函数、拷贝构造函数、赋值运算符重载、 重载移动构造函数、重载移动赋值操作符函数等特性，可以更高效地管理资源和对象的生命周期，避免内存泄漏和资源浪费。希望本篇博客能够帮助读者。
【C++篇】C++类与对象深度解析（四）：初始化列表、类型转换与static成员详解
半截诗的博客~
09-18 1901
本篇文章是《C++类与对象详解》系列的第四篇聚焦于C++中更为高级的编程技巧，包括构造函数中的初始化列表、类型转换的各种场景以及static静态成员的使用与管理。文章首先详细讲解了初始化列表的用法及其在提升代码效率方面的优势，特别是在处理常量、引用类型以及没有默认构造函数的类类型变量时的应用。接着，探讨了C++中内置类型与类类型之间的隐式与显式转换，并介绍了如何利用explicit关键字避免潜在的类型转换陷阱。最后，深入解析了静态成员变量和静态成员函数的特性、初始化方式以及它们在实际编程中的应用场景。
《深度探索c++对象模型》第三章笔记
StudyWinter的博客
07-26 616
每一个nonstatic data member的偏移量( offset）在编译时期即可获知，甚至如果member属于一个base class subobject(派生自单一或多重继承串链）也是一样.因此，存取一个nonstatic data member，其效率和存取一个C struct member或一个nonderived class的member是一样的。下一节我会验证“继承对于member布局的影响”。多重继承的一个语意上的副作用就是，它必须支持某种形式的“sharedsubobject继承”。
(C++)深度探索C++对象模型_C++_
10-03
4. **构造函数与析构函数**：构造函数是在创建对象时自动调用的特殊函数，用于初始化对象的数据成员。析构函数在对象生命周期结束时调用，用于清理对象可能占用的资源。 5. **内存管理**：C++提供了两种内存区域：...
LeiHeDuiXiang.rar_类和对象
09-23
在编程世界中，类和对象是面向对象编程（OOP，Object-Oriented Programming）的基础概念，也是Java、Python、C++等许多主流编程语言的核心特性。本篇将深入探讨这两个概念及其在实际编程中的应用。 类是面向对象...
C++实验：类与对象的构造析构函数探索
【资源摘要信息】: "本实验报告关注C++中的高级程序设计，主要涉及类和对象的概念，特别是构造函数和析构函数的运用。实验旨在帮助学生深入理解this指针、构造函数、拷贝构造函数、构造函数重载以及析构函数的工作...
C++面向对象：从结构到类的探索
"C++类的描述，包括从结构到类的转变，成员函数，构造函数，析构函数，以及动态存储。" 在C++中，面向对象编程是一种重要的编程范式，它基于类和对象的概念。【4.1从结构到类】这一部分主要讲述了如何从传统的C语言...
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 245
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 204
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 79
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
【C语言】预处理(预编译)详解(下)（C语言最终篇）
hdxbufcbjuhg的博客
10-29 2258
在编译⼀个程序的时候我们如果要将⼀条语句（⼀组语句）编译或者放弃编译，就可以使用条件编译，比如调试性的代码删掉很浪费，保留又很碍事，我们就可以使用条件编译，在编译的时候不编译这些调试性的代码在这里我们就可以使用一个技巧，在最开头使用#define定义一个符号，如果我们没有注释或者删除这个符号，那么我们就可以编译里面的调试性代码，进行正常调试，如果我们注释或者删除这个符号，那么我们就不编译里面的调试性代码，不影响代码的正常运行。
第20课-C++【二叉搜索树】
2401_83603768的博客
10-25 1173
二叉搜索树（Binary search tree）是一种特殊的二叉树，它的每个节点的左子树中的所有节点值都小于该节点值，而右子树中的所有节点值都大于该节点值。
C++ -- 模板进阶
最新发布
zy1215058242的博客
11-02 543
一个程序/项目由若干源文件共同实现，而每个源文件单独编译生成目标文件，最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式。模板复用了代码，节省资源，更快的迭代开发，C++的标准模板库(STL)因此而产生。增强了代码的灵活性。模板会导致会导致代码代码膨胀问题，也会导致编译时间变长。出现模板编译错误时，错误信息非常凌乱，不易定位错误。
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

祐言QAQ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值