C++语法基础(一)

第一个C++程序

1. (C++)

是 C++ 标准库中的头文件,用于处理输入输出操作。它提供了基于流(stream)的输入输出机制。

特点:
  • 面向对象:C++ 中的输入输出操作是基于流的,这种机制是面向对象的。流可以看作是字节序列的抽象,输入流从数据源(如键盘或文件)读取数据,输出流将数据写入目标(如屏幕或文件)。
  • 常用的流对象
    • std::cin:标准输入流,通常与键盘关联,用于从用户输入读取数据。
    • std::cout:标准输出流,通常与显示器关联,用于输出数据到屏幕。
    • std::cerr:标准错误流,通常与显示器关联,用于输出错误信息。
    • std::clog:标准日志流,用于输出日志信息。

2. (C)

是 C 标准库中的头文件,用于处理输入输出操作。它提供了一些用于文件操作和标准输入输出的函数。

特点:
  • 基于函数的输入输出:C 语言中的输入输出操作是基于函数的。常见的输入输出函数包括 printfscanffprintffscanffgetsfputs 等。
  • 低级别:与 C++ 的面向对象的流相比,C 的输入输出更为低级,操作更加直接。
//#include
#include

int main(){
   // printf("hello world\n");
    std::cout << "hello world" << std::endl;
    return 0;
}

  我们可以先暂时理解为endl \n 一样,功能就是输出时换行,它们有一些重要的区别,endl 是 C++ 标准库中的一个操控符(manipulator),它不仅用于在输出流中插入一个换行符,还会刷新输出缓冲区(flush the output buffer)。这意味着,endl 会强制将缓冲区中的内容立即输出到目标设备(如屏幕),而不仅仅是插入一个换行符。对于作用限定符::我们可以先简单地理解为什么中的什么。

命名空间

        命名空间(namespace) 是 C++ 中用于组织代码的一种机制,它允许将代码分组到不同的命名空间中,以避免名称冲突,特别是在大型项目或使用多个库时。命名空间为变量、函数、类等标识符提供了一个作用域,可以防止不同命名空间中的标识符相互干扰。

代码演示

#include
namespace ICBC{
    int g_money = 0;
    void pay(int money){
        g_money -= money;
    }
    void save(int money){
        g_money += money;
    }
}
namespace CCB{
    int g_money = 0;
    void pay(int money){
        g_money -= money;
    }
    void save(int money){
        g_money += money;
    }
}

int main(){
    ICBC::pay(1000);
    ICBC::save(3000);
    CCB::save(10000);
    CCB::pay(2000);
    std::cout << "工行卡的余额:" << ICBC::g_money << std::endl;
    std::cout << "建行卡的余额:" << CCB::g_money << std::endl;
}

        在使用命名空间后,相同名字的变量和函数并没有发生冲突

名字空间声明

代码演示

//名字空间声明
#include
using namespace std;
namespace ns{
    int v_tomato = 10;
}
int main(){
    int v_tomato = 30;
    using ns::v_tomato; //从这行代码开始,ns中的内容引入当前作用域(相当于定义)
    //上面的定义会造成重定义报错
    v_tomato = 20;  
    cout << "ns::v_tomato = " << ns::v_tomato << endl;
    return 0;
}

        因为所有标准库提供的 类型、对象和函数都位于std名字空间 ,所以我们在使用using namespace std;后,就可以对输出代码的写法进行简化,省略std::

 代码分析 

C++语法基础(一)_第1张图片

         编译器在编译每一个函数时都会构造两张表,在编译这个函数(main函数)结束后销毁。在函数体内定义的变量会放进定义表,对于函数体外定义的对本函数可见的变量会放进可见表。对于本例,使用名字空间声明也相当于在这个函数体内定义了这个变量,又因为函数体内先前已经定义了这个变量(int v_tomato=30),此时的名字空间声明会造成重定义,这是编译器绝对不允许的,因此会报错。当在函数内使用某个标识符时,如果存在同名,编译器需要确定你使用的是哪一个标识符,因此他会拿着这个名字先在定义表中查看,如果定义表中找不到,才会到可见表中找。

名字空间指令(using namespace [...])

        名字空间指令是指使用 using namespace 语句将整个命名空间引入当前作用域。这意味着命名空间中的所有标识符都可以直接使用,而不必再通过命名空间限定符来引用。这种方式在简化代码的同时也可能带来名称冲突的风险,尤其是在大型项目中。 

代码演示

//名字空间指令
#include
using namespace std;
namespace ns{
    int v_tomato = 10;
}
int main(){

    using namespace ns; //从这行代码开始,ns中的内容在当前作用域中可见
    //ns::v_tomato = 20;
    v_tomato = 20;
    //std::cout << ns::v_tomato << std::endl;
    cout << "ns::v_tomato = " << ns::v_tomato << endl;
    return 0;
}

在上面的代码中,using namespace ns; 是一个名字空间指令,它将 ns1命名空间中的所有标识符引入到 main 函数的作用域中,因此你可以直接使用 v_tomato 而不需要在前面加上 ns::。 

 代码分析(不同于上个代码)

C++语法基础(一)_第2张图片

         对于本例,代码的输出结果依然是10,我们来分析一下。main函数内的int v_tomato = 10,这是一个放在定义表的局部变量,而对于ns命名空间的int v_tomato = 10是放在可见表中的。当出现v_tomato = 20这个变量,编译器需要确定究竟是这两个同名变量中的哪一个,编译器会先在定义表中寻找,此时他找到了就不会查看可见表,因此v_tomato = 20修改的是main函数内定义的局部变量而不是ns命名空间的同名变量。这也就是最后我们的输出结果依然是v_tomato = 10的原因,因为它实际上并没有修改我们ns命名空间中的这个变量。

 名字空间指令和名字空间声明的差别

        使用名字空间指令会让所指定命名空间的内容在当前作用域中可见,其中定义的变量会被放入可见表中,而使用名字空间声明会让所指定命名空间中的内容引入当前作用域(相当于定义),其中定义的变量放入定义表中

代码演示

//名字空间指令 和 名字空间声明 的差别
#include
using namespace std;
namespace ns1{
    int g_money = 10;
    int g_other = 10;
}
namespace ns2{
    int g_money = 10;
    int g_other = 10;
}
int main(){
    using namespace ns1;//ns1中的所有内容都出现在可见表中
    using ns2::g_other;//只有ns2::g_other出现在定义表中
    
    g_money = 100;//修改的是ns1中的g_money
    cout << "ns1::g_money = " <//命名空间的嵌套
#include
using namespace std;

namespace ns1{
    int g_money = 10;
    namespace ns2{
        int g_money = 20;
        namespace ns3{
            int g_money = 30;
            namespace ns4{
                int g_money = 40;
            }
        }
    }
}

int main(){
    //名字空间别名可以简化书写
    namespace ns_forth = ns1::ns2::ns3::ns4;
    //cout << ns1::ns2::ns3::ns4::g_money << endl;
    cout << ns_forth::g_money << endl;
}

扩展

        我们说使用名字空间声明引入的变量相当于定义在main函数中的变量,那他们有什么区别?

在C++中,namespace中的变量(如ns::v_tomato)通常具有进程级生命周期

1. 进程级生命周期的定义

  • 进程级生命周期的变量从程序开始执行(通常是在程序的初始化阶段)到程序结束时一直存在。
  • 这些变量通常分配在全局/静态数据区中,生命周期贯穿整个程序的运行过程。

2. namespace中的变量的生命周期

  • namespace ns { int v_tomato = 10; }
    • 这里的v_tomato是在命名空间ns中定义的全局变量。
    • 虽然它被封装在namespace中,但它的本质仍是一个全局变量。
特点:
  • 存储位置v_tomato会存储在全局/静态数据区中,而不是栈或堆中。这意味着它在程序的整个生命周期内都存在。
  • 生命周期:从程序启动时开始(即在main()函数执行之前),直到程序终止时结束。因此,它具有进程级的生命周期。
  • 作用范围:虽然v_tomato的作用范围被限制在命名空间ns中,但它仍然是一个全局变量。这意味着在程序的任何地方,只要通过ns::v_tomato访问,它都可以被引用和修改。

3.示例分析 

#include 

namespace ns {
    int v_tomato = 10; // 进程级生命周期的变量
}

int main() {
    std::cout << "v_tomato = " << ns::v_tomato << std::endl; // 输出 10
    ns::v_tomato = 20;
    std::cout << "v_tomato = " << ns::v_tomato << std::endl; // 输出 20
    return 0;
}

在这个示例中:

  • v_tomato 在程序开始时被初始化为10,并且在整个程序的生命周期中都存在。
  • 你可以在main()函数中(或程序的其他地方)访问和修改它的值。
  • 当程序结束时,v_tomato才会被销毁。

4. 总结

  • namespace中的变量v_tomato 是具有进程级生命周期的全局变量。
  • 它从程序启动时初始化,并在程序结束时销毁。
  • 尽管被封装在namespace中,它的生命周期和其他全局变量一样,不受namespace本身的影响。

你可能感兴趣的:(c++,开发语言,vim,命名空间,vscode,c语言)