C++基础篇 day_01

Lynn He

已于 2025-01-15 09:45:08 修改

阅读量1.7k

点赞数 60

分类专栏： C++的命名空间文章标签： c++ 开发语言

于 2025-01-14 19:54:56 首次发布

本文链接：https://blog.youkuaiyun.com/weixin_44029028/article/details/145143301

版权

C++的命名空间专栏收录该内容

1 篇文章

订阅专栏

一、输入输出流

1、输入输出流

C++ 中并没有定义任何内置的输入输出语句，而是通过标准库提供 I/O机制。这个库就是我们常用的 iostream 库，iostream 库中定义了两个基础类型：istream 和 ostream，分别代表输入流和输出流。

流：流是一种数据传输方式，它代表一个字符序列，从输入设备读取或者写入到输出设备中。流的意思是，随着时间的推移，字符是按顺序生成或者消耗的。

标准库中定义了四个常用的流对象

cout   // 标准输出流（输出到屏幕）	Ostream
cin    // 标准输入流（从键盘输入）	Istream   
cerr   // 标准错误流（输出错误信息）	Ostream 
clog   // 标准日志流（输出运行信息）	Ostream

2、准备工作

2.1、C++中源文件的后缀名

.cpp  	// 最常用
.C		// 大写
.cxx
.cc

2.2、C++中头文件

C++中的标准头文件不需要加.h，使用方式如下：

#include <iostream>

此外，C++兼容C语言的头文件，但写法不同。不是使用 #include <stdio.h> 这种形式，而是写成如下方式：

#include <cstdio>
#Include <stdio.h>   --- > cstdio    cstring

2.3、C++的编译方式

C++中通常使用 g++ 编译器，编译命令如下：

g++ xxx.cpp -o xx.out

如果使用 gcc 编译器编译 C++ 程序，则需要手动连接 C++ 的库，示例如下：

gcc xxx.cpp -lstdc++

2.4、main 函数的返回值

在 C++ 中，main 函数的返回值必须是 int 类型，否则会报错，并且 main 函数必须返回一个值。

3、示例

下面是一个简单的C++中的输入输出程序

输出：

#include <iostream>
#include <cstring>
#include <cstdlib>

int main(int argc , char const *argv[])
{
    std::cout << "C++ hello" << std::endl;
    return 0;
}

输入：

#include <iostream>
#include <cstring>

// main 函数开始
int main(int argc, char const *argv[])
{
    // 创建变量
    int val_1 = 10;
    int val_2 = 10.1;
    std::string str_1 = "张三";
    std::string str_2 = "是帅哥";

    // 输出
    std::cout << "val_1 = " << val_1 << std::endl;
    std::cout << "val_1 = " << val_2 << std::endl;

    // 输入
    std::cin >> val_1;
    // 输出
    std::cout << "val_1 = " << val_1 << std::endl;

    // 返回
    return 0;
}

二、C++命名空间

1、命名空间的使用

我们的程序中使用的是 std::cout 和 std::cin，而不是直接写 cout 和 cin。这是因为 C++ 中的所有标准库内容都放在了一个叫 std 的命名空间里。命名空间的作用是为了避免不同代码之间的名字冲突。

为什么需要命名空间？

想象一下，如果有两个人都用“张三”这个名字，大家会混淆他们是谁。命名空间就像在名字前面加上姓氏一样，帮助区分不同的功能。例如，std::cout 表示标准库中的 cout，而 cout 可能在其他地方有不同的定义。

如何简化命名空间的使用？

如果你觉得每次都写 std:: 太麻烦，可以使用下面两种方法：

1.使用 `using` 声明

在程序开始的地方加上：

using namespace std;

这样，你就可以直接写 cout、cin，而不用每次都加 std:: 了。例如：

#include <iostream>
using namespace std;

int main() {
    cout << "请输入两个数：" << endl;
    int a, b;
    cin >> a >> b;
    cout << "a + b = " << a + b << endl;
    return 0;
}

2.引入特定的对象

如果你只想简化某些部分的代码，也可以只引入需要的部分：

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

这样你就只需要给这些部分去掉 std::，其他的内容不受影响。

2、自己编写命名空间

在 C++ 中，我们可以自己定义命名空间，将相关的变量、函数等封装到一个命名空间里，避免与其他部分的代码产生冲突。定义命名空间的基本格式如下：

namespace 命名空间名{
	数据类型1 变量1;
	数据类型2 变量2;
	...
	数据类型n 变量n;
}

下面通过三个例子来展示在不同情况下如何使用命名空间：

情况一：两个命名空间内变量名重复

#include <iostream>
#include <cstring>

using namespace std;

// 定义两个命名空间
namespace test_1 {
    char name[20];
    int age;
}

namespace test_2 {
    char name[20];
    int age;
}

// 使用两个命名空间
using namespace test_2;
using namespace test_1;

int main()
{
    // 由于两个命名空间的变量名重复，不能直接使用变量名，否则会产生歧义。
    // 需要使用“命名空间名::变量名”的方式来访问。
    test_1::age = 18;
    test_2::age = 30;
    
    cout << "test_1::age = " << test_1::age << endl;
    cout << "test_2::age = " << test_2::age << endl;
    
    return 0;
}

情况二：命名空间与全局变量冲突

当命名空间中的变量与全局变量发生冲突时，通常使用作用域运算符 :: 来访问全局变量，避免歧义。

这种方式我们称为匿名空间或者域调用

#include <iostream>
#include <cstring>

using namespace std;

// 定义两个命名空间
namespace test_1 {
    char name[20];
    int age;
}

namespace test_2 {
    char name[20];
    int age;
}

using namespace test_1;
using namespace test_2;

// 全局变量
int age;

int main()
{
    test_1::age = 18;
    test_2::age = 30;
    
    // 使用 "::age" 访问全局变量，避免与命名空间中的变量冲突 <匿名空间>  <域调用>
    ::age = 50;
    
    cout << "test_1::age = " << test_1::age << endl;
    cout << "test_2::age = " << test_2::age << endl;
    cout << "Global age = " << ::age << endl;
    
    return 0;
}

情况三：命名空间与局部变量冲突

当命名空间中的变量与局部变量发生冲突时，程序会优先使用局部变量。此时，可以通过命名空间名来明确使用命名空间中的变量。

#include <iostream>
#include <cstring>

using namespace std;

// 定义两个命名空间
namespace test_1 {
    char name[20];
    int age;
}

namespace test_2 {
    char name[20];
    int age;
}

// 使用两个命名空间
using namespace test_2;
using namespace test_1;

int main()
{
    test_1::age = 18;
    test_2::age = 30;
    
    // 局部变量
    int age;
    age = 50; // 优先使用局部变量
    
    cout << "test_1::age = " << test_1::age << endl;
    cout << "test_2::age = " << test_2::age << endl;
    cout << "Local age = " << age << endl;
    
    return 0;
}

3、命名空间封装函数

在 C++ 中，命名空间不仅可以封装变量，还可以封装函数。这种方式可以将不同功能模块分开，避免命名冲突。通过命名空间封装函数，我们可以轻松管理同名的函数、变量，使代码结构更加清晰。

下面通过一个示例展示如何将函数封装在命名空间中，并解释不同情况下的使用方法。

4、命名空间嵌套

在 C++ 中，命名空间不仅可以独立存在，还可以嵌套在其他命名空间中。嵌套命名空间的作用是将更细粒度的功能模块分组管理。通过命名空间的嵌套，我们可以进一步组织代码，避免命名冲突。

示例代码：

#include <iostream>
#include <string>

using namespace std;
// 类内声明 类外定义

// 命名空间内套函数
namespace Func
{
    int add(int val_1, int val_2);
};

using namespace Func;

int Func::add(int val_1, int val_2)
{
    return val_1 + val_2;
}

// 命名空间内套命名空间
namespace student_system
{
    // 登录
    namespace log_in
    {
        string name;
        string passwoed;
        int id;

    };
    // 学生
    namespace student
    {
        string name;
        int id;
    };
}
using namespace student_system;


int main(int argc, char const *argv[])
{
    student_system::student::name = "10";

    student::name = "10";

    cout << Func::add(90, 80) << endl;

    return 0;
}

5、作用域运算符 `::`

在 C++ 中，:: 被称为作用域运算符，它用于告诉编译器我们想要访问哪个范围内的某个变量、函数或者类。简单来说，它可以帮助我们明确指定要使用的对象在哪个地方定义的。

1.命名空间中的使用

就像前面提到的，我们用 std::cout 来表示标准库中的 cout。这里的 :: 就表示我们正在使用 std 命名空间里的 cout。

std::cout << "Hello, World!" << std::endl;

这里的 :: 明确告诉编译器：我们要用的是 std 命名空间里的 cout 和 endl。

2.全局作用域

如果在局部作用域（如函数内部）中，存在与全局变量同名的变量，可以使用 :: 来访问全局变量。例如：

int num = 10; // 全局变量

int main() {
    int num = 5; // 局部变量
    std::cout << "局部 num: " << num << std::endl;   // 输出 5
    std::cout << "全局 num: " << ::num << std::endl; // 使用 :: 访问全局 num，输出 10
    return 0;
}

这里的 ::num 表示全局变量 num，避免和局部变量 num 冲突。

3.类中的使用

当类有多个成员函数或成员变量时，作用域运算符也用于区分类中的具体成员。例如：

class MyClass {
public:
    static int value;
};

int MyClass::value = 0; // 使用 :: 来定义类的静态成员

这里 MyClass::value 表示的是 MyClass 类的静态成员 value。

总结
命名空间：使用 `std::cout` 时的 `::` 表示使用 `std` 命名空间中的 `cout`。
全局变量：可以用 `::` 来区分全局变量和局部变量。
类中的使用：`::` 用于访问类的成员函数或静态变量。

三、C++中的字符串

在 C++ 中，字符串类型实际上是通过字符串类（string 类）来操作的。这种类方式的操作使得字符串处理更加方便。这里我们对字符串类进行一个简单的介绍，后续学习容器时还会深入了解字符串作为容器的更多功能。

os == cout
is == cin

os << s               将 s 写到输出流 os 当中，返回 os
is >> s               从 is 中读取字符串赋给 s，字符串以空白分隔，返回 is
getline(is, s)        从 is 中读取一行赋给 s，返回 is 可以用于获取一行数据
s.empty()             s 为空返回 true，否则返回 false
s.size()              返回 s 中字符的个数
s[n]                  返回 s 中第 n 个字符的引用，位置 n 从 0 计起
s1 + s2               返回 s1 和 s2 连接后的结果
s1 = s2               用 s2 的副本代替 s1 中原来的字符
s1 == s2              如果 s1 和 s2 中所含的字符完全一样，则它们相等；string 对象的相等性判断对字母的大小写敏感
s1 != s2              不相等，判断字母的大小写敏感
<, <=, >, >=          利用字符在字典中的顺序进行比较，且对字母的大小写敏感

1、使用方式

要使用 C++ 中的 string 类，需要包含 string 头文件：

#include <string>

2、赋值操作

C++ 的 string 类支持多种赋值方式：

string s1 = "Hello";      // 直接赋值
string s2;
s2 = "World";             // 使用赋值运算符
string s3(s1);            // 拷贝构造
string s4(5, 'A');        // 重复字符赋值，s4 = "AAAAA"

3、字符串拼接

使用 + 运算符或 append() 函数进行字符串拼接：

string s1 = "Hello, ";
string s2 = "World!";
string s3 = s1 + s2;       // 使用 + 进行拼接
s1.append(" C++");         // 使用 append 函数拼接

4、查找和替换

string 提供了 find() 和 replace() 函数用于查找和替换子字符串：

string s = "Hello, World!";
size_t pos = s.find("World");  // 查找子字符串 "World"
if (pos != string::npos) {
    s.replace(pos, 5, "C++");  // 替换为 "C++"
}

5、字符串比较

C++ 中可以直接使用关系运算符（如 ==, !=, <, > 等）来比较 string 对象：

string s1 = "apple";
string s2 = "banana";

if (s1 == s2) {
    cout << "The strings are equal" << endl;
} else if (s1 < s2) {
    cout << "s1 comes before s2" << endl;
}

6、字符串存取

可以使用下标操作符 [] 或 at() 方法来访问和修改字符串中的字符：

string s = "Hello";
char c = s[1];      // 访问第二个字符 'e'
char c2 = s.at(2);  // 使用 at() 方法访问第三个字符 'l'

注意：[] 不会检查越界，而 at() 会进行越界检查。

7 、字符串插入

使用 insert() 函数可以在指定位置插入子字符串：

string s = "Hello!";
s.insert(5, " C++");  // 在索引5的位置插入 " C++"，结果为 "Hello C++!"

8、字符串删除

string 类提供 erase() 函数来删除字符串中的部分内容：

string s = "Hello, C++!";
s.erase(5, 7);  // 从索引5开始，删除7个字符，结果为 "Hello"

9 、字符串清空

可以使用 clear() 函数来清空字符串的内容：

string s = "Hello!";
s.clear();  // 清空字符串，s 变为空字符串 ""

10、风格转换

1、C++ 字符串转 C 风格字符串

使用 string 类的 .c_str() 成员函数可以将 C++ 字符串转换为 C 风格的字符串（const char*）。

#include <iostream>
#include <string>
using namespace std;

int main() {
    string cppStr = "Hello, C++";
    const char* cStr = cppStr.c_str();  // 转换为 C 风格字符串
    printf("%s\n", cStr);  // 使用 C 风格函数
    return 0;
}

2、C 风格字符串转 C++ 字符串

C 风格的字符串（字符数组）可以直接赋值给 C++ 的 string，C++ 会自动进行转换。

#include <iostream>
#include <string>
using namespace std;

int main() {
    const char* cStr = "Hello, C";
    string cppStr = cStr;  // 自动转换为 C++ 字符串
    cout << cppStr << endl;
    return 0;
}

总结

C++ 转 C：使用 .c_str()。
C 转 C++：直接赋值即可。

四、C++中的结构体

C++中结构体和类的唯一的区别，就是默认的访问控制权限不同：

类中成员的默认访问权限：private
结构体中成员的默认访问权限：public

下面是一些和C语言的区别

1、定义与变量声明

C语言： 如果不使用 typedef 为结构体起别名，那么在定义结构体变量时必须显式使用 struct 关键字。例如：
```
struct Person {
    char name[50];
    int age;
};

struct Person p;  // 必须使用 struct 关键字
```
C++： C++ 允许直接使用结构体名来定义变量，无需每次都加上 struct 关键字：
```
struct Person {
    char name[50];
    int age;
};

Person p;  // 不需要 struct 关键字
```

2 、允许定义函数

C语言： 在 C 中，结构体只能封装数据，不能直接包含函数。不过，可以使用函数指针在结构体中存储函数地址，但这仍然不能将函数本身封装在结构体中。
```
struct Person {
    char name[50];
    int age;
    void (*printName)(struct Person*);  // 使用函数指针来关联函数
};
```

C++： C++ 的结构体允许封装函数，使得结构体能够像类一样包含成员函数。这意味着结构体不仅可以存储数据，还可以通过成员函数操作数据。以下是一个示例：

#include <iostream>

using namespace std;

// 结构体
struct mystruct {
    int M_num;

    char func(int num) {  // 成员函数
        M_num = num;
        return (char)M_num;
    }

    void show_num() {  // 成员函数
        cout << "M_num = " << M_num << endl;
    }
};

int main() {
    mystruct str;
    str.func(12);
    str.show_num();  // 调用成员函数显示 M_num 的值
    return 0;
}

在 C++ 中，结构体与类几乎没有区别（除了默认的访问权限外，结构体默认是 public 的），可以包含数据成员和成员函数。这使得 C++ 的结构体功能大大增强，能够支持面向对象编程。

五、C++中的bool类型

bool 类型是 C++ 中用于表示布尔值的数据类型，表示真或假。

1 取值

true：表示真，数值为 1。
false：表示假，数值为 0。

2 使用示例

#include <iostream>
using namespace std;

int main() {
    bool isTrue = true;   // 布尔变量赋值为 true
    bool isFalse = false; // 布尔变量赋值为 false

    cout << isTrue << endl;  // 输出 1
    cout << isFalse << endl; // 输出 0

    return 0;
}