当前位置： 首页 > article >正文

【C++语言】C++入门

article 2025/2/11 18:00:42

一、命名空间

       在 C/C++ 中，变量、函数和后面的类都是大量存在的，这些变量、函数和类的名称将都存在于全局作用域中，可能会导致很多冲突。使用命名空间的目的是对标识符的名称进行本地化，用于避免命名冲突或者名字污染，namespace关键字就是针对这种问题的。

#include <stdio.h>
#include <stdlib.h>

int rand = 10;
// C语言没办法解决类似这样的命名冲突问题，所以C++提出了namespace来解决

int main()
{
    printf("%d\n", rand);
    return 0;
}

// 编译后后报错：error C2365: “rand”: 重定义；以前的定义是“函数”

1.1 命名空间的定义

       定义命名空间，需要使用到 namespace 关键字，后面跟着命名空间的名字，然后接一对 { } 即可，{ } 中即为命名空间的成员。

// 1. 正常的命名空间定义
namespace hrx
{
     // 命名空间中可以定义变量/函数/类型
     int rand = 10;
     int Add(int left, int right)
     {
         return left + right;
     }

     struct Node
     {
         struct Node* next;
         int val;
     };
}

//2. 命名空间可以嵌套
// test.cpp
namespace N1
{
    int a;
    int b;
    int Add(int left, int right)
    {
         return left + right;
    }
    namespace N2
    {
         int c;
         int d;
         int Sub(int left, int right)
         {
             return left - right;
         }
    }
}

//3. 同一个工程中允许存在多个相同名称的命名空间,编译器最后会合成同一个命名空间中。
// ps：一个工程中的test.h和上面test.cpp中两个N1会被合并成一个
// test.h
namespace N1
{
    int Mul(int left, int right)
    {
        return left * right;
    }
}

注意：一个命名空间就定义了一个新的作用域，命名空间中的所有内容都局限于该命名空间中。 

1.2 命名空间的使用 

命名空间的使用有三种方式：

  • 加命名空间名称以及作用域限定符（常用）
  • 使用 using 将命名空间中的某一个成员引入（常用）
  • 使用 using namespace 命名空间名称引入（不常用）

二、C++ 输入&&输出

在程序员的学习中，永远都有一个梗：hello world。

#include<iostream>

// std是C++标准库的命名空间名，C++将标准库的定义实现都放到这个命名空间中
using namespace std;

int main()
{
    cout<<"Hello world!!!"<<endl;
    return 0;
}

说明：

  1. 使用cout标准输出对象(控制台)和cin标准输入对象(键盘)时，必须包含< iostream >头文件 以及按命名空间使用方法使用std。
  2. cout和cin是全局的流对象，endl是特殊的C++符号，表示换行输出，他们都包含在包含< iostream >头文件中。
  3. <<是流插入运算符，>>是流提取运算符。
  4. 使用C++输入输出更方便，不需要像printf/scanf输入输出时那样，需要手动控制格式。C++的输入输出可以自动识别变量类型。
  5. 实际上cout和cin分别是ostream和istream类型的对象，>>和<<也涉及运算符重载

注意：早期标准库将所有功能在全局域中实现，声明在.h后缀的头文件中，使用时只需要包含对应的头文件即可，后来将其实现在 std 命名空间下，为了和c头文件区分，也为了正确使用命名空间，规定C++头文件不带.h。 

三、缺省函数

3.1 缺省函数的概念

       缺省函数是声明或者定义函数时为函数的参数指定一个缺省值。在调用该函数时，如果没有指定实参，则使用该参数的缺省值，否则使用指定的实参。

void Func(int a = 0)
{
     cout<<a<<endl;
}
int main()
{
     Func();     // 没有传参时，使用参数的默认值
     Func(10);   // 传参时，使用指定的实参
     return 0;
}

3.2 缺省函数的分类

  • 全缺省参数
void Func(int a = 10, int b = 20, int c = 30)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }
  • 半缺省参数
void Func(int a, int b = 10, int c = 20)
 {
     cout<<"a = "<<a<<endl;
     cout<<"b = "<<b<<endl;
     cout<<"c = "<<c<<endl;
 }

注意：

  1. 半缺省参数必须从右往左依次来给出，不能间隔给
  2. 缺省参数不能在函数声明和定义中同时出现 
  3. 缺省值必须是常量或者全局变量
  4. C语言不支持（编译器不支持）
  //a.h
  void Func(int a = 10);
  
  // a.cpp
  void Func(int a = 20)
  {}
  
  // 注意：如果生命与定义位置同时出现，恰巧两个位置提供的值不同，那编译器就无法确定到底该
用那个缺省值。

四、函数重载

       在自然语言中，一个词语可以有多重含义，人们可以通过上下文来判断该词语真实的含义，即该次被重载了。

4.1 函数重载的概念

       函数重载：是函数的一种特殊概念，C++允许在同一个作用域中声明几个功能类似的同名函数，这些同名函数的形参列表（参数个数 或者 类型 或者 类型顺序）不同，常用来处理实现功能类似数据类型不同的问题。

#include<iostream>
using namespace std;

// 1、参数类型不同
int Add(int left, int right)
{
     cout << "int Add(int left, int right)" << endl;
     return left + right;
}

double Add(double left, double right)
{
     cout << "double Add(double left, double right)" << endl;
     return left + right;
}


// 2、参数个数不同
void f()
{
     cout << "f()" << endl;
}

void f(int a)
{
 cout << "f(int a)" << endl;
}


// 3、参数类型顺序不同
void f(int a, char b)
{
     cout << "f(int a,char b)" << endl;
}

void f(char b, int a)
{
     cout << "f(char b, int a)" << endl;
}

int main()
{
     Add(10, 20);
     Add(10.1, 20.2);
     f();
     f(10);
     f(10, 'a');
     f('a', 10);
     return 0;
}

4.2 C++支持函数重载的原理——名字修饰

为什么C++支持函数重载，而C语言不支持函数重载呢？？

在 C/C++ 中，一个程序要运行起来，需要经历以下几个阶段：预处理，编译，汇编，链接。

  1. 实际项目通常是由多个头文件和多个源文件构成的，而通过C语言的编译链接，我们可以知道，当前 a.cpp 中调用了 b.cpp 中定义的 Add 函数时，编译后链接前，a.o 的目标文件中没有 Add 的函数地址，因为 Add 是在 b.cpp 中定义的，所以 Add 的地址在 b.o 中。
  2. 链接阶段就是专门处理这种问题的，链接器看到 a.o 调用 Add，但是没有 Add 的地址，就会到 b.o 的符号表中找 Add 的地址，然后链接到一起。
  3. 我们可以看到 gcc 的函数修饰后名字不变，但是 g++ 的函数修饰后变成了【_Z + 函数长度 + 函数名 + 类型首字母】。

采用 C 语言编译器编译后结果：

结论：在 Linux 下，采用 gcc 编译完成后，函数名字的修饰没有发生改变。

采用 C++ 编译器编译后结果：

结论：在 Linux 下，采用 g++ 编译完成后， 函数名字的修饰发生改变，编译器将函数参数类型信息添加到修改后的名字中。

五、引用

5.1 引用的概念

       引用不是新定义一个变量，而是给已存在的变量取一个别名，编译器不会为引用变量开辟内存空间，他和他引用的变量共用同一块内存空间。

类型 & 引用变量名 ( 对象名 ) = 引用实体； 
void TestRef()
{
    int a = 10;
    int& ra = a;//<====定义引用类型
    printf("%p\n", &a);
    printf("%p\n", &ra);
}

注意：引用类型必须和引用实体是同种类型的 

5.2 引用的特性

  1. 引用在定义时必须初始化
  2. 一个变量可以有多个引用
  3. 引用一旦引用一个实体，再不能引用其他实体
void TestRef()
{
   int a = 10;
   // int& ra;   // 该条语句编译时会出错
   int& ra = a;
   int& rra = a;
   printf("%p %p %p\n", &a, &ra, &rra);  
}

5.3 常引用

void TestConstRef()
{
    const int a = 10;
    //int& ra = a;   // 该语句编译时会出错，a为常量
    const int& ra = a;
    // int& b = 10; // 该语句编译时会出错，b为常量
    const int& b = 10;
    double d = 12.34;
    //int& rd = d; // 该语句编译时会出错，类型不同
    const int& rd = d;
}

5.4 使用场景

  • 做参数
void Swap(int& left, int& right)
{
   int temp = left;
   left = right;
   right = temp;
}
  • 做返回值
int& Count()
{
   static int n = 0;
   n++;
   // ...
   return n;
}

注意：如果函数返回时，出了函数作用域，如果返回对象还在（还没有还给系统），则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。 

5.5 传值、值引用效率比较

       以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时拷贝，因此用值作为参数或者返回值类型效率是比较低下的，尤其是当参数或者返回值类型非常大时，效率就更低了。

#include <time.h>
struct A{ int a[10000]; };
void TestFunc1(A a){}
void TestFunc2(A& a){}
void TestRefAndValue()
{
     A a;
     // 以值作为函数参数
     size_t begin1 = clock();
     for (size_t i = 0; i < 10000; ++i)
         TestFunc1(a);
     size_t end1 = clock();

     // 以引用作为函数参数
     size_t begin2 = clock();
     for (size_t i = 0; i < 10000; ++i)
         TestFunc2(a);
     size_t end2 = clock();

     // 分别计算两个函数运行结束后的时间
     cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
     cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}

5.6 引用和指针的区别

在语法概念上，引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
    int a = 10;
    int& ra = a;
    cout<<"&a = "<<&a<<endl;
    cout<<"&ra = "<<&ra<<endl;
    return 0;
}

在底层实现上，实际上是有空间的，因为引用是按照指针方式来实现的。

我们来看一看引用和指针的汇编代码的对比：

引用和指针的不同点：

  1. 引用概念上定义一个变量的别名，指针存储一个变量地址
  2. 引用在定义时必须初始化，指针没有要求
  3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
  4. 没有NULL引用，但有NULL指针
  5. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
  6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
  7. 有多级指针，但是没有多级引用
  8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理
  9. 引用比指针使用起来相对更安全

六、内联函数

6.1 内联函数的概念

       以 inline 修饰的函数佳作内联函数，编译时 C++ 编译器会在调用内联函数的地方展开，没有函数调用建立栈帧的开销，内联函数提升程序运行的效率。

       如果在函数前增加 inline 关键字将其改成内联函数，在编译期间编译器会用函数体替换函数的调用。

6.2 内联函数的特性

  1. inline是一种以空间换时间的做法，如果编译器将函数当成内联函数处理，在编译阶段，会用函数体替换函数调用，缺陷：可能会使目标文件变大，优势：少了调用开销，提高程序运行效率。
  2. inline对于编译器而言只是一个建议，不同编译器关于inline实现机制可能不同，一般建议：将函数规模较小(即函数不是很长，具体没有准确的说法，取决于编译器内部实现)、不是递归、且频繁调用的函数采用inline修饰，否则编译器会忽略inline特性。
  3. inline不建议声明和定义分离，分离会导致链接错误。因为inline被展开，就没有函数地址了，链接就会找不到。

【面试题】宏的优缺点？

  • 优点：
    • 增加代码的复用性。
    • 提高性能。
  • 缺点：
    • 不方便调试宏。（因为预编译阶段进行了替换）
    • 导致代码可读性差，可维护性差，容易误用。
    • 没有类型安全的检查。 

【面试题】C++ 有哪些技术替换宏？

  • 常量定义换用 const enum
  • 短小函数定义换用内联函数


http://www.kler.cn/a/540965.html

相关文章：

  • Qt - 地图相关 —— 2、Qt调用百度在线地图功能示例全集，包含线路规划、地铁线路查询等（附源码）
  • 【动态规划篇】：动态规划解决路径难题--思路，技巧与实例
  • 81页精品PPT | 华为流程与信息化实践与架构规划分享
  • 【go】交叉编译
  • AMD 8845HS 780M核显部署本地deepseek大模型的性能
  • shell脚本控制——使用新的shell启动脚本
  • 【生产变更】- Oracle RAC添加配置ipv6地址
  • 最简单方法本地部署deepseek及其他大模型（如Llama、千问等），有手就行
  • 【非 root 用户下全局使用静态编译的 FFmpeg】
  • 蓝桥杯---数青蛙（leetcode第1419题）
  • Ruby 日期 时间处理指南
  • c/c++蓝桥杯经典编程题100道（20）最长公共子序列
  • 把DeepSeek 装进 VSCode中
  • 接入 deepseek 实现AI智能问诊
  • Hive之[Hive]详细安装步骤
  • Python 实现 macOS 系统代理的设置
  • 防火墙综合练习2
  • 使用Python爬虫获取1688 App原数据API接口
  • deepseek大模型集成到idea
  • AI技术填坑记2：标注系统
  • MATLAB中count函数用法
  • unity学习30：Audio Source, Audio clip 音效和音乐
  • python卷积神经网络人脸识别示例实现详解
  • 如何保证Redis和MySQL数据的一致性刨析
  • 求助DeepSeek帮我开发一个直线审批流程设计页面Vue2.0
  • Linux系统编程之信号基础知识