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

认识c++（c++入门）

article 2024/11/23 5:18:33

1. C++关键字

C++关键字是语言本身的一部分，它们有特定的含义，并被用作程序的基础结构。以下是C++标准中定义的关键字列表：

2. 命名空间

在C++中，命名空间（Namespace）是一种用来组织代码的方法，它可以避免名称冲突。在大型项目中，当不同的开发者或模块使用相同的变量名或函数名时，命名空间可以确保每个名称在它自己的空间内保持唯一。

命名空间的基本用法

定义命名空间

你可以使用namespace关键字来定义一个命名空间。下面是一个简单的例子：

namespace myNamespace {
    int var = 10;
    void func() {
        std::cout << "Inside myNamespace::func()" << std::endl;
    }
}

在这个例子中，myNamespace是命名空间的名称，var和func是这个命名空间内的变量和函数。

使用命名空间成员

要使用命名空间内的成员，可以使用作用域解析运算符::。

int main() {
    std::cout << myNamespace::var << std::endl; // 输出 10
    myNamespace::func(); // 调用命名空间内的函数
    return 0;
}

命名空间嵌套

命名空间可以嵌套，即在一个命名空间内定义另一个命名空间。

namespace outerNamespace {
    int outerVar = 20;
    namespace innerNamespace {
        int innerVar = 30;
    }
}

使用`using`指令

你可以使用using指令来简化命名空间成员的访问。

using声明：引入命名空间中的一个特定成员。

using myNamespace::func;
// 现在可以直接调用func()，不需要使用作用域解析运算符
func();

using编译指令：引入整个命名空间的所有成员。

using namespace myNamespace;
// 现在可以直接使用命名空间内的所有成员
std::cout << var << std::endl;
func();

无名命名空间

无名命名空间是一个特殊的命名空间，其成员在定义它们的文件中具有内部链接，这意味着它们不能在文件外部被访问。

namespace {
    int hiddenVar = 42;
}
// hiddenVar 只能在当前文件中使用

注意事项

命名空间可以跨越多个文件，但通常将相关的声明和定义放在同一个头文件中。
避免在头文件中使用using编译指令，因为这可能会导致名称冲突。
使用标准命名空间（如std）时，通常只在函数或代码块内部使用using声明，而不是整个文件。

通过使用命名空间，C++代码变得更加模块化和可维护，减少了全局命名空间中的混乱。

3. C++输入&输出

在C++中，输入和输出通常是通过标准库中的iostream库来实现的，该库定义了用于输入输出的对象，如std::cin用于标准输入，std::cout用于标准输出，std::cerr用于标准错误输出。

输出

使用std::cout可以进行标准输出，通常与插入运算符<<一起使用。

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl; // 输出字符串并换行
    int number = 42;
    std::cout << "The answer is " << number << std::endl; // 输出变量值
    return 0;
}

输入

使用std::cin可以进行标准输入，通常与提取运算符>>一起使用。

#include <iostream>

int main() {
    int value;
    std::cout << "Enter an integer: ";
    std::cin >> value; // 从标准输入读取一个整数
    std::cout << "You entered: " << value << std::endl;
    return 0;
}

注意事项

使用iostream库时，需要包含头文件<iostream>。
std::endl是一个操纵符，它在输出流中插入一个换行符，并刷新输出缓冲区。
在进行输入操作时，如果输入的类型与期望的类型不匹配，可能会导致未定义行为。
可以使用std::cin.fail()来检查输入操作是否失败，如果失败，可以使用std::cin.clear()来清除错误状态，并使用std::cin.ignore()来忽略错误输入后的字符。

4. 缺省参数

在C++中，缺省参数（也称为默认参数）允许你在函数声明中为参数指定一个默认值。如果在函数调用时没有为这些参数提供值，则它们将使用这些默认值。这是非常有用的特性，它可以使函数更加灵活，并减少需要编写和维护的函数重载数量。

定义缺省参数

在函数原型中，你可以通过在参数声明后赋值来指定缺省参数

#include <iostream>

// 函数声明时指定默认参数
void printInfo(const std::string& name = "Unknown", int age = -1) {
    std::cout << "Name: " << name;
    if (age >= 0) {
        std::cout << ", Age: " << age;
    }
    std::cout << std::endl;
}

int main() {
    printInfo();            // 使用默认参数
    printInfo("Alice");     // 只提供第一个参数
    printInfo("Bob", 30);   // 提供所有参数
    return 0;
}

在上面的例子中，printInfo函数有两个参数，name和age。name的默认值是字符串"Unknown"，而age的默认值是-1。

注意事项

缺省参数必须从右到左提供。也就是说，如果一个参数有默认值，它右边的所有参数也必须有默认值。
函数原型和函数定义中的默认参数必须一致。如果函数原型中指定了默认参数，函数定义中可以省略这些默认值。
默认参数的值可以是常量、全局变量、函数调用等，但不能是局部变量。
当函数重载时，默认参数可能会导致调用歧义。

5. 函数重载

函数重载（Function Overloading）是C++中的一个特性，它允许在同一作用域内定义多个同名函数，只要它们的参数列表（参数的个数或类型）不同即可。编译器会根据传递给函数的参数来决定调用哪个函数。

函数重载的条件

要实现函数重载，必须满足以下条件：

函数名称相同：重载的函数必须具有相同的名字。
参数列表不同：参数的数量或参数的类型必须不同。仅仅返回类型不同不足以构成重载。
在同一作用域：重载的函数必须在同一个作用域内。

函数重载的例子

下面是一个简单的函数重载的例子：

#include <iostream>

// 函数声明
void print(int num);
void print(double num);
void print(const char* str);

// 函数定义
void print(int num) {
    std::cout << "Integer: " << num << std::endl;
}

void print(double num) {
    std::cout << "Double: " << num << std::endl;
}

void print(const char* str) {
    std::cout << "String: " << str << std::endl;
}

int main() {
    print(10);         // 调用 print(int)
    print(3.14);       // 调用 print(double)
    print("Hello");    // 调用 print(const char*)
    return 0;
}

在这个例子中，我们定义了三个名为print的函数，每个函数接受不同类型的参数。根据传递给print函数的参数类型，编译器会决定调用哪个函数。

注意事项

返回类型：函数重载时，返回类型不能作为区分函数的唯一标准。即你不能仅通过改变返回类型来重载函数。
缺省参数：使用缺省参数时，要注意不要造成重载的歧义。例如，如果你有两个重载函数，其中一个比另一个多一个带默认值的参数，调用时如果不提供该参数的值，可能会导致编译器无法确定调用哪个函数。
构造函数重载：在类中，构造函数也可以重载，以提供不同的初始化方式。

查看全文

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