【探索C++】C++对C语言的扩展

已于 2023-09-20 15:03:58 修改
阅读量470 收藏 17
点赞数 17
分类专栏： 探索C++编程 文章标签： c++ c语言 开发语言
于 2023-09-20 15:03:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64928278/article/details/133044833
版权

一、 引用

1. 变量名         

        变量名本质上就是一段连续内存空间的名字，相当于一个标记，可以用变量名来申请并命名内存空间，可以借助变量名来使用这个空间。

int a = 10; // 声明一个整数变量a，分配内存空间

2. 引用的概念

        变量名本身为一块内存的引用，C++中的引用其实就是给一个已有的变量再取一个别名（alias）。

int x = 5; int &y = x; // 创建y作为x的引用

3. 语法格式

变量名
类型 &引用名 = 变量名

float f = 3.14;
//取别名的方式，给变量f取一个别名叫a
float &a = f;

4. 规则

        （1）引用没有定义，只是一种关系类型声明，所以不分配内存，声明它和原有某一变量的关系，所以类型要保持一致；

        （2）声明时必须初始化，一经声明，不可更改；

        （3）可以对引用再次进行引用；

        （4）只有&前面有类型时，是引用，若没有类型，则是其他意思。

5. 引用作为函数参数

        普通引用在声明的时候必须用其他变量进行初始化，但是作为函数形参的时候，不需要进行初始化（因为这个初始化过程在函数调用的时候）实参给形参做初始化。

void func(int &a)
{
    cout << "a = " << a << endl;
}

6. 引用作为函数返回

        引用作为函数返回的时候，可以将这个函数作为赋值运算的左值（结果为赋值运算的值），需要保证函数返回的引用空间在函数退出的时候，没有被释放（全局变量，堆空间数据，静态局部变量，传入的指针数据）。

int &func(int &a)
{
    return a;
}

int main(int argc, char const *argv[])
{
    int a = 200;
    int b = func(a);
    //int b = func(a) = 300;  //可以作为左值
    cout << b << endl;
    
    return 0;
}

7. 引用的意义

        （1）在很多时候引用可以代替指针使用；

        （2）引用在函数传参的使用中对于指针具有更好的可读性和实用性。

8. 引用的本质         

        引用在C++中的内部实现是一个常指针：type &name <====> type * const name。

        C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。 从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间，这是C++为了实用性而做出的细节隐藏。

9. 指针引用

void func1(int *&a)
{
    a[2] = a[0] + a[4];

}



int main(int argc, char const *argv[])
{
    int *p = new int[5]{10,20,30,40,50};
    
    func1(p);
    
    for (int i = 0; i < 5; ++i)
    {
        cout << p[i] << " ";
    }
    cout << endl;
    
    return 0;
}

10. const引用

const引用的特征

  • const引用有较多使用，它可以防止对象的值被随意更改。
  • const对象的引用必须是const的，将普通引用绑定到const对象是不合法的。
const int a = 20;
// int &b = a;    //不合法的
const int &b = a;
  • const引用可以使用相关类型的对象（常量，非同类型的变量或表达式）初始化，这个是const引用与普通引用最大的区别。
int &m = 20;    //不合法的
const int &m = 20;

（1）const引用的原理：        

        const引用的目的是禁止通过修改引用的值来改变被引用的对象。const引用的初始化特性较为微妙，可以看如下代码：

double d = 20.34;
const int &a = d;
double &b = d;

cout << a << " " << b << endl;
d = 23.34;
cout << a << " " << b << endl;

        输出结果为：

20 20.34
20 23.34

        实际上，const引用使用相关类型对象初始化时发生如下过程：

double d = 20.34;
const int &a = d;
//int tmp = d;
//const int &a = tmp;

二、 默认参数和占位参数

1. 默认参数

        通常情况下，函数在调用的时候，形参从实参那里取得值，对于多次调用同一函数同一实参时，C++给出了更简单的处理方法，给形参给默认值，这样就不用从实参哪里取值了。

默认参数规则：

        （1）只有参数列表的后面部分才可以提供默认参数（从右往左依次带默认参数）。

        （2）一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值。

//int add(int a = 10, int b, int c = 100)    //语法错误，不能跳着带默认参
//int add(int a = 10, int b, int c)    //语法错误，不能从左开始带默认参
int add(int a, int b, int c = 100)    //形参带默认参数
{
    return a+b+c;    
}


int main(int argc, char const *argv[])
{
    cout << add(10, 20, 30) << endl;
    
    return 0;
}

2. 占位参数

        占位参数只有类型声明，没有参数名声明。占位参数在函数里面不能使用，为了以后函数做拓展留下线索。

/占位参数在函数里面能不能使用？不能使用
//占位参数为了以后函数做拓展留下线索
int add(int a, int b, int c, int = 0)    //形参带占位参数，占位参数还带有默认参数
{
    
    return a+b+c;
}

//int add(int a, int b, int = 0, int c = 0)
//占位参数，占位参数可以跟默认参数一起结合使用，前提是默认参要从右到左依次赋值

//int add(int a, int b, int, int c)
//占位参数可以放在任意位置



int main(int argc, char const *argv[])
{
    cout << add(10, 20, 30, 40) << endl;
    
    return 0;
}

三、C++函数重载

1. 函数重载

        函数重载是C++中一种允许你使用相同的函数名定义多个不同参数列表的函数的机制。函数重载的规则如下：

  • 函数名相同；
  • 参数列表不同，可以通过参数个数、参数类型和参数顺序的不同来区分；
  • 返回类型不同的函数不能构成重载。

以下是一些函数重载的示例（这些函数都具有相同的名称func，但参数列表不同，因此构成了函数重载）：

        void func(int a) {}

        void func(float f) {}

        void func(int a, float f) {}

        void func(float a, float f) {}

        void func(float a, int f) {}

        void func(double a, char f) {}

        void func(float a, char f, int m) {}

        int func(char a, char f) {}

2. 调用准则

        当调用重载函数时，编译器会根据传递的参数选择最匹配的函数。它会按照以下准则来寻找可行的候选函数：

        （1）严格匹配，找到则调用；

        （2）通过隐式类型转换技术寻找匹配的函数，找到则调用；

        （3）一个函数不能即做重载，又作默认参数的函数，当你少写一个参数时，系统无法确认是重载函数默认参数。

3. 函数重载与函数指针结合

        函数指针可以指向不同参数列表的函数，但在赋值时要注意确保参数匹配。示例：

typedef void (*FUNC1)(int, int, int);
typedef void (*FUNC2)(int, int);

int main() {
    FUNC1 p1 = func; // 调用func(int, int, int)
    FUNC2 p2 = func; // 调用func(int, int)
    
    p1(10, 20, 30);
    p2(10, 20);
    
    return 0;
}

4. 函数重载总结

        函数重载是C++中的一种强大机制，它允许定义多个具有相同名称但参数列表不同的函数。以下是一些函数重载的总结：

  • 函数名相同，参数列表不同即可构成重载；
  • 函数返回值不能作为函数重载的依据；
  • 编译器根据传递的参数选择最匹配的函数。

四、运算符重载

        运算符重载是C++中另一个强大的特性，它允许你自定义数据类型的运算符行为。通过运算符重载，你可以使自定义类型像内置类型一样参与各种运算。

1. 运算符重载的基本原理

        运算符重载的基本原理是为自定义类型定义与运算符相关的函数。例如，如果你想要为自定义的Complex类实现+运算符，可以这样做：

class Complex {
public:
    Complex operator+(const Complex& other) {
        Complex result;
        result.real = this->real + other.real;
        result.imag = this->imag + other.imag;
        return result;
    }
private:
    double real;
    double imag;
};

2. 运算符重载的示例

class Complex {
public:
    Complex operator+(const Complex& other) {
        Complex result;
        result.real = this->real + other.real;
        result.imag = this->imag + other.imag;
        return result;
    }
    
    bool operator==(const Complex& other) {
        return (this->real == other.real) && (this->imag == other.imag);
    }
    
    Complex operator*(const Complex& other) {
        Complex result;
        result.real = this->real * other.real - this->imag * other.imag;
        result.imag = this->real * other.imag + this->imag * other.real;
        return result;
    }
    
    // 其他运算符重载也可以类似定义
private:
    double real;
    double imag;
};

3. 运算符重载的使用

        运算符重载使自定义类型的对象可以像内置类型一样使用运算符。例如：

Complex c1(1.0, 2.0);
Complex c2(3.0, 4.0);
Complex c3 = c1 + c2; // 使用+运算符重载
bool isEqual = (c1 == c2); // 使用==运算符重载
Complex c4 = c1 * c2; // 使用*运算符重载

五、命名空间

1.概念

        所谓namespace，是指标识符的各种可见范围，C++标准程序库当中所有的标识符都被定义在一个名为std的namespace中。

（1）<iostream>和<iostream.h>

        格式不一样，前者没有后缀，实际上，在你的编译器include文件夹里面可以看到，二者是两个文件，打开文件就会发现，里面的代码是不一样的，后缀为.h的头文件C++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h的后缀文件里，C++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h，因此：

        当<iostream.h>使用时，相当于在C中调用库函数，使用的是全局命名空间；

        当<iostream>使用时，该文件没有定义全局命名空间，必须使用using namespace std；这样才能正确使用cin，cout。

（2）由于namespace的概念，使用C++标准程序库中的任何标识符是，可以有三种选择：

用法1：在用的时候加上std:: 比较麻烦

        int a; std::cin >> a; // std::cout << a << std::endl; //

用法2：用的时候打开一部分，建议用的，安全性，命名空间的污染度不高

        using std::cin; using std::cout; using std::endl;

用法3：直接打开全部的，不安全，容易造成命名空间污染，出现重复定义，多次引用，解释如下：

        using namespace std;

        因为标准库非常的庞大，所以程序员在选择的类的名称或函数名 时就很有可能和标准库中的某个名字相同。所以为了避免这种情况所造成的名字冲突，就把标准库中的一切都被放在名字空间std中。但这又会带来了一个新问 题。无数原有的C++代码都依赖于使用了多年的伪标准库中的功能，他们都是在全局空间下的。所以就有了<iostream.h> 和<iostream>等等这样的头文件，一个是为了兼容以前的C++代码，一个是为了支持新的标准。命名空间std封装的是标准程序库的名称，标准程序库为了和以前的头文件区别，一般不加".h"

2. C++命名空间定义以及使用方法


        在C++中，名称可以是符号常量，变量，宏，函数，枚举，类和对象等等，为了避免在大规模程序的设计中，以及在程序员在使用各种的C++库时，这些标识符的命名发生冲突。
        标准C++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。
        std是C++标准命名空间，C++标准程序库中所有标识符都被定义在std中，比如标准库中的类iostream、vector、map等都定义在该命名空间中，使用时要加上using声明（using namespace std）或者using指示（using std::cin using std::cout using std::endl using std::vector<int>  std::map<int, string>...）

C中的命名空间：
        在C语言中只有一个命名空间，全局作用域
        C语言中所有的全局标识符共享同一个作用域
        标识符之间可能发生冲突
C++中的命名空间：
        命名空间将全局作用域分成不同的部分
        不同命名空间中的标识符可以同名而且不会发生冲突
        命名空间可以相互嵌套
        全局作用域也叫做默认命名空间

（1）C++命名空间的定义
namespace name {...}
namespace {...}        //匿名命名空间，里面的内容只能在当前文件使用
（2）C++命名空间的使用
namespace A{int n;}
1、直接全部（打开）放出来       using namespace A;
2、只打开一部分                using A::n;
3、用到谁就使用谁              A::n;

namespace {int n}
使用默认匿名空间里面的变量      ::n
默认情况下，可以直接使用默认命名空间里面的所有标识符

3. C++命名空间代码实现

#include <iostream>

using namespace std;

namespace A
{
    int a;
}

namespace B
{    
    int a;
    int b;
    int c;
    namespace C     //可以嵌套命名空间
    {
        char name[20];
    }
    struct Stu         //可以嵌套结构体
    {
        int num;
    }d;
    void func(){cout << "123456" << endl;}        //可以嵌套函数
}

namespace     //匿名命名空间，简单点来讲就是全局命名空间
{
    int a;
    int b;
}

namespace     //匿名命名空间可以定义两个，但是里面不用出现相同的标识符
{    
    int d;    
}

//1、直接全部打开，全部裸露出来，但是会造成命名空间污染，不建议
// using namespace B;
// using namespace B::C;

//2、只放出一部分
using B::c;
// using B::C::name;

int main(int argc, char const *argv[])
{
    a = 200;    //默认情况下，可以直接使用默认命名空间里面的所有标识符
    cout << "a = " << a << endl;
    
    ::b = 300;    //使用匿名命名空间里面的标识符
    cout << "b = " << ::b <<  endl;
    
    c = 300;
    cout << "c = " << c << endl;
    
    //3、直接用命名空间::成员名
    B::func();
    
    cin >> B::C::name;
    cout << B::C::name << endl;
        
    return 0;
}

4. 总结

        引入命名空间：在使用某个命名空间中的成员之前，通常需要引入该命名空间。可以使用 using namespace name 来引入整个命名空间，也可以使用 using name::member 来引入特定的成员。

        命名空间的使用：在C++中，<iostream>等标准库头文件通常没有定义在全局命名空间中，因此使用其中的成员时，需要使用 using namespace std; 或者在使用时前缀以 std::，例如 std::cout。

        头文件命名规范：为了与C语言区分开，C++标准规定头文件不使用后缀 .h，而是直接使用不带后缀的文件名。

        命名空间的定义：命名空间的定义使用 namespace name {...} 的形式，其中 name 是命名空间的名称，而 {...} 内包含了该命名空间的成员。

        命名空间的嵌套：C++允许嵌套命名空间，这意味着你可以在一个命名空间内再定义另一个命名空间，从而更好地组织和管理代码。

        命名空间是C++中用于避免命名冲突和组织代码的有用工具，它有助于将代码模块化，使代码更具可维护性和可读性。熟练掌握命名空间的使用是C++编程的重要一步。

六、内敛函数

        C++提供了内联函数（inline functions）这一重要特性，它可以帮助程序员优化代码执行效率，减少函数调用的开销。本文将详细介绍内联函数的特点、使用场景以及与宏替换的区别，帮助你更好地理解和利用这一功能，从而实现了真正的内嵌。

#include <iostream>

using namespace std;

inline void func(int a)    //内敛函数   
{
    cout << "a = " << a << endl;
}

int main(int argc, char const *argv[])
{
    func(100);    //调用函数有 保护现场 和 恢复现场 这两个过程
    // {
    //     cout << "a = " << a << endl;
    // }
    
    return 0;
}

1.内联函数特点

        （1）内联函数使用 inline 关键字声明，通常与函数定义结合在一起；
        （2）内联函数的代码被编译器直接插入到函数调用的地方，类似于宏替换，减少了函数调用的开销；
        （3）内联函数具有普通函数的特征，包括参数检查和返回类型。


2. 内联函数的优点

        （1）提高程序运行效率，减少了函数调用时的入栈和出栈操作；
        （2）内联函数可以作为类的成员函数，可以访问所在类的保护成员和私有成员。


3. 内联函数的限制

        （1）内联函数的函数体应该相对较小，避免过于复杂的代码；
        （2）不适合包含循环或大量条件判断的函数体；
        （3）不能对内联函数进行取址操作。


4.内联函数与宏替换的区别

        （1）内联在编绎时展开，宏在预编译时展开。 展开的时间不同。

        （2）编译内联函数可以嵌入到目标代码，宏只是简单文本替换。

        （3）内联会做类型，语法检查，而宏不具这样功能。

        （4）宏不是函数，inline函数是函数

        （5）宏定义小心处理宏参数（一般参数要括号起来），否则易出现二义性，而内联定义不会出现。

#include <iostream>

using namespace std;

#define SQ(x) ((x)*(x))

inline int sq(int x)
{
    return x*x;
}


int main(int argc, char const *argv[])
{
    int i = 0;
    for (int i = 0; i < 5; ++i)
    {
        // cout << sq(i+1) << endl;//1 4 9 16 25
        cout << SQ(i+1) << endl;// 1 4 9 16 25
    }
    
    return 0;
}


5.适用场景

        （1）内联函数适用于函数体相对简单且被频繁调用的情况；
        （2）当函数体较大或包含复杂的逻辑时，内联可能不会带来明显的性能提升；
        内联函数是C++中一种用于提高程序性能的重要技术，但需要注意适用场景和代码复杂度，以充分发挥其优势。熟练使用内联函数可以有效地减少函数调用带来的开销，提高程序的运行效率。

七、C++头文件和extern "C"

（1）标准C++的头文件引用

#include //C++的标准输入输出头文件

（2）如果要在C++程序里面用标准C的头文件

//#include <stdio.h>
//#include <stdlib.h>
#include  <cstdio>
#include  <cstdlib>

        注意：不是所有的.h的头文件都是以c开头，去.h尾。

（3）使用C语言的相关函数的时候，头文件的引用方式

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

        写一个练习吧：设计一个计算圆柱体体积的函数，表面积函数，P值和圆柱体的高都有默认参数。

#include <iostream>

using namespace std;

void func1(int r, int h = 10, float PI = 3.14)	//计算圆柱体体积
{
	cout << "圆柱体的体积：" << r*r*PI*h << endl;
}

void func2(int r, int h = 10, float PI = 3.14)	//计算圆柱体表面积
{
	cout << "圆柱体的表面积：" << (2*r*r*PI)+(2*PI*r*h) << endl;
}

int main(int argc, char const *argv[])
{
	cout << "输入圆柱体的半径跟高" << endl;
	int r, h;
	cin >> r >> h;
	if (h > 0)
	{
		func1(r, h);
		func2(r, h);
	}
	else
	{
		func1(r);
		func2(r);
	}

	return 0;
}

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

   手撕C语言

            玩转linux

                    脚踢数据结构

                            系统、网络编程

                                     探索C++

                                             6818（ARM）开发板实战

📢写在最后

  • 今天的分享就到这啦~
  • 觉得博主写的还不错的烦劳 一键三连喔~
  • 🎉🎉🎉感谢关注🎉🎉🎉
祐言QAQ
关注
  • 17
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 29
    评论
专栏目录
最新Dev-C++下载安装以及C语言环境搭建教程（含C语言入门教程）
兔子王
11-27 3万+
最新Dev-C++下载安装以及C语言环境搭建教程，快来看看吧！
学习C++之前要先学习C语言吗？
C语言C++学习俱乐部：765860056
07-15 1194
C++读作“C加加”，是“C Plus Plus”的简称。顾名思义，C++ 是在C语言的基础上增加新特性，玩出了新花样，所以叫“C Plus Plus”，就像 iPhone 7S 和 iPhone 7、Win10 和 Win7 的关系。从语法上看，C语言是 C++ 的一部分，C语言代码几乎不用修改就能够以 C++ 的方式编译，这给很多初学者带来了不小的困惑，学习 C++ 之前到底要不要先学习C语言呢？我对这个问题保持中立，但是初学者直接学习 C++ 会非常吃力，Hold 不住，尤其是对计算机内存不太理解的.
C++对C语言数据类型的扩展
qq_36091214的博客
12-19 1175
1.4 C++对C语言数据类型的扩展 1.4.1 结构体 1.4.2 联合 1.4.3 枚举 1.4.4 布尔 1.4.5 字符串 1.5 类型转换
从C语言快速过渡到C++
CMtotoe的博客
01-22 3505
帮助学会C语言的同学快速过渡到C++
c++相比C语言扩展的内容
feng_a_feng的博客
02-18 1567
1、全局变量检测增强。如果定义两个相同名称的全局变量，c语言下是不会报错的，c++下会报错。 2、类型的扩展，c++有bool类型，c语言下没有。 3、struct结构体的增强，c++下可以存放函数，c语言下不可以。 4、函数检测增强，c++下 函数的参数必须要填写变量的类型，c语言则没有这样严格，可写或不写。 5、三目运算符的增强,c++下放回的是变量，可以再对返回的变量赋值；而c语言下返回的是...
【C++语法】基于C语言补充的一些基础C++语法
记录学习点滴
09-26 1338
C++是在C的基础之上，容纳进去了面向对象编程思想，并增加了许多有用的库，以及编程范式等。补充C语言语法的不足，以及C++是如何对C语言设计不合理的地方进行优化的，比如：作用域方面、IO方面、函数方面、指针方面、宏方面等。为后续类和对象学习打基础因为C++是在C的基础上扩展和补充，所以在C++中是兼容C语言的，C语言的语法都可以在C++中使用！！！定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。
学c++要不要先学C语言？
南风fahaxiki
10-13 2602
不，首先学习C++。C++ 的C子集对于C/C++ 的新手是比较容易学的，又比C本身容易使用。原因是C++（通过强类型检查）提供了比C更好的保证。进一步说，C++ 还提供许多小特征，例如运算符new，与C语言对应的东西相比，它们的写法更方便，也更不容易出错。这样，如果你计划学习C和C++（而不只是C++），你不应该经由C那条迂回的路径。为能很好地使用C，你需要知道许多窍门和技术，这些东西在C++ 里的任何地方都不像它们在C里那么重要、那么常用。
C语言和C++的区别和联系
weixin_55751709的博客
08-28 1423
C语言和C++的区别和联系
VSCode的C/C++扩展功能
热门推荐
泠山的博客
02-21 1万+
VSCode的C/C++扩展功能1. 在 Linux 上 使用 C++1.1 创建 Hello World1.2 探索 IntelliSense1.3 构造 helloworld.cpp1.3.1 运行 build1.3.2 修改 tasks.json二级目录三级目录 Reference: Visual Studio Code的C/C++扩展功能 Using C++ on Linux in VS Code 1. 在 Linux 上 使用 C++ 1.1 创建 Hello World 从 termina
C++1-C语言和C++的区别
kyrie_sakura的博客
09-23 2905
C语言和C++的区别
C++中对C语言结构体用法的扩充
08-26
C++中对C语言结构体用法的扩充是指在C++语言中对C语言结构体的扩展和改进，包括了在结构体中实现方法设置、规定私有数据类型和公有数据类型等特性。 在C语言中，结构体（struct）是一种基本的数据类型，用于组合多...
c语言c++项目源代码_c语言矿井逃生.rar
03-27
4. **开源可扩展**：项目源码完全开放，玩家可以根据自己的喜好进行二次开发和定制，打造独一无二的游戏体验。 无论你是C语言初学者还是资深开发者，《C语言矿井逃生》都是一个不可多得的优质资源。快来下载体验吧...
c语言c++项目源代码_c语言对对碰游戏源码.rar
03-27
本源码采用C语言编写，实现了游戏的基本功能，并提供了良好的可扩展性和定制性，适合初学者学习和二次开发。 游戏中，玩家需要通过点击或按键来控制己方的棋子，与对方的棋子进行碰撞。碰撞后，如果满足一定条件，...
c语言c++项目源代码_c语言五子棋源码.rar
03-27
**C语言五子棋源码.rar 资源介绍** C语言五子棋源码是一个集趣味性与技术性于一体的中小型C语言项目。该项目通过简洁高效的代码实现了一个具有人机对战功能的五子棋游戏。对于初学者来说，它是一个很好的实践和学习...
c语言c++项目源代码_c语言自创军旗游戏源码.rar
03-27
该游戏源码基于C语言开发，具有高度的灵活性和可扩展性。您无需担心安装和配置问题，只需下载并解压源码包，即可开始您的军旗游戏开发之旅。同时，源码中附有详细的文档说明，帮助您快速理解游戏结构和实现原理。 ...
C语言| 数组的折半查找
最新发布
qq_40555264的博客
06-22 976
3 此时a[2]=87,而key > a[2]=87,说明256在87的右边，则往右边查找。high = mid-1 = 2, 更新mid =(low+high)/2=1。low = mid+1, 更新mid=(low+high)/2，high不变。high = mid-1,更新mid=(low+high)/2,low不变。low = mid+1 =2, 更新mid =(low+high)/2=2。low = mid+1=4, 更新mid=(low+high)/2=5;
C的I/O操作
weidl001的博客
06-17 729
输入输出（I/O）操作在C语言编程中占据重要地位，包括文件与目录操作、字符流与字节流处理，以及序列化与反序列化。通过深入理解和掌握这些I/O操作，程序员可以实现与外部环境的高效数据交互，为各种应用场景提供稳定可靠的解决方案。无论是文本文件的读写、二进制数据的处理，还是复杂数据结构的序列化和反序列化，这些I/O操作的掌握都对编写高效、健壮的C程序至关重要。
C++ shared_ptr
qq_40135848的博客
06-15 1534
C++ shared_ptr
【C++提高编程-05】----C++之Deque容器实战
一伦明悦的博客
06-15 1174
Deque（双端队列）是C++ STL中的一种序列容器
简述c++语言对c语言特点
03-26
4. 低级别的编程风格：C语言直接操作内存，对程序员要求较高，但也提供了更灵活的编程方式。 5. 面向过程：C语言的编程思想主要是面向过程的，自顶向下的设计方法更加适合C语言的开发方式。 6. 库函数：C语言提供...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 29
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

祐言QAQ

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

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

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

打赏作者

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

抵扣说明：

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

余额充值