C++(关键字)

于 2024-09-28 19:50:12 发布
阅读量530 收藏 3
点赞数 8
文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77143270/article/details/142620540
版权

5. 作用域限定符 ::

5.1 名字空间（掌握）

名字空间是一种代码的层级划分。

#include <iostream>

using namespace std;
// C++课程中几乎所有的类型（不包括基本数据类型）都在std中

int a = 1;

// 新建一个名字空间
namespace my_space {
    int a = 3;
    string s = "哈哈哈";
}

namespace my_space2 {
    int a = 4;
    string s = "嘿嘿嘿";
}

// 使用自己的名字空间
using namespace my_space2;


int main()
{
    int a = 2;
    std::cout << "你好" << std::endl;
    cout << a << endl; // 2
    cout << ::a << endl; // 1

    // 访问my_space的内容
    cout << my_space::a << my_space::s << endl;
    // 访问my_space2的内容
    cout << my_space2::a << s << endl;

    return 0;
}

5.2 类内声明，类外定义（重点）

函数是可以声明定义分离的，成员函数也可以声明定义分离，把成员函数的声明放置在类内，把成员函数的定义放置在类外，因为定义在类外，所以需要类名::来制定定义的函数是哪个类的。

#include <iostream>

using namespace std;

class Student
{
private:
    string name;

public:
    // 类内声明
    Student(string n);
    string get_name();
    void set_name(string n);
};

// 类外定义
Student::Student(string n)
{
    name = n;
}

string Student::get_name()
{
    return name;
}

void Student::set_name(string n)
{
    name = n;
}

int main()
{
    Student s("张三");
    s.set_name("张三丰");
    cout << s.get_name() << endl;

    return 0;
}

5.3 配合静态使用

在后续static关键字中讲解。

6. this关键字

6.1 概念（掌握）

this在类中表示一个指针：this指针，是一种特殊的指针，保存了当前类对象的首地址（指向了当前类的对象）。、

#include <iostream>

using namespace std;

class Student
{
private:
    string name;

public:
    Student(string n):name(n)
    {
        cout << this << endl;
    }

    string get_name()
    {
        cout << this << endl;
        return name;
    }

    void set_name(string n)
    {
        cout << this << endl;
        name = n;
    }
};



int main()
{
    Student s("张三");
    cout << &s << endl;
    s.set_name("张三丰");
    cout << s.get_name() << endl;

    cout << endl;

    Student* s2 = new Student("李四");
    cout << s2 << endl;
    cout << s2->get_name() << endl;

    return 0;
}

6.2 调用成员（掌握）

结论：成员必须由对象调用。

#include <iostream>

using namespace std;

class Student
{
private:
    string name;

public:
    Student(string n)
    {
        this->name = n;
        cout << this->get_name() << endl;
    }

    string get_name()
    {
        return this->name;
    }

    void set_name(string n)
    {
        this->name = n;
    }
};

上面的代码中，所有在类内调用成员的位置，如果程序员不写this指针（实际上没有必要手写，比较繁琐），编译器都会在成员调用之前添加this指针。

6.3 区分重名的成员变量与局部变量（掌握）

#include <iostream>

using namespace std;

class Student
{
private:
    string name;

public:
    Student(string name)
    {
        this->name = name;
    }

    string get_name()
    {
        return name;
    }

    void set_name(string name)
    {
        this->name = name;
    }
};



int main()
{
    Student s("Tom");
    cout << s.get_name() << endl;
    s.set_name("Jerry");
    cout << s.get_name() << endl;

    return 0;
}

6.4 链式调用（熟悉）

结论：如果一个成员函数的返回值是当前类型的引用，说明这个函数支持链式调用，return的内容一定是*this。

#include <iostream>

using namespace std;

class Value
{
private:
    int value;

public:
    Value(int value)
    {
        this->value = value;
    }

    Value& add(int value)
    {
        this->value += value;
        return *this;
    }

    int get_value()
    {
        return value;
    }
};



int main()
{
    Value v1(0);
    // 普通的调用方式：分步操作
    v1.add(1);
    v1.add(2);
    v1.add(4);
    v1.add(7);
    cout << v1.get_value() << endl; // 14

    cout << endl;

    Value v2(0);
    // 链式调用
    cout << v2.add(1).add(2).add(4).add(7).get_value() << endl; // 14
    cout << v2.get_value() << endl; // 14

    return 0;
}

7. static关键字

7.1 静态局部变量（掌握）

使用static修饰的局部变量就是静态局部变量，所在的函数第一次被调用时创建，直到程序运行结束销毁，所有的对象共用这个一个静态局部变量。

#include <iostream>

using namespace std;

class Test
{
public:
    void test_static()
    {
        int a = 1;
        static int b = 1; // 局部静态变量
        cout << a++ << endl;
        cout << b++ << endl << endl;
    }
};

int main()
{
    Test t1;
    Test t2;
    t1.test_static();
    t2.test_static();
    t1.test_static();

    return 0;
}

7.2 静态成员变量（掌握）

使用是static关键字修饰的成员变量就是静态成员变量。

静态成员变量具有以下特点：

1. 非const修饰的静态成员变量不能在类内初始化，必须在类外初始化。

2. 同一个类的所有对象共享一份静态成员变量。

3. 静态成员变量可以直接通过类名调用，无需关联任何对象，因为静态成员变量在程序执行时创建，在程序结束时销毁。

#include <iostream>

using namespace std;

class Test
{
public:
    int a = 1; // 成员变量
    static int b; // 静态成员变量
};

int Test::b = 1; // 类外初始化

int main()
{
    // 通过类名直接调用静态成员变量
    cout << Test::b << " " << &Test::b << endl;

    Test t1;
    Test t2;
    cout << t1.a++ << " " << &t1.a << endl;
    cout << t2.a++ << " " << &t2.a << endl;
    cout << t1.b++ << " " << &t1.b << endl;
    cout << t2.b++ << " " << &t2.b << endl;

    return 0;
}

7.3 静态成员函数（掌握）

使用static修饰的成员函数就是静态成员函数，静态成员函数具有以下特点：

1. 没有this指针，因此不能调用非静态成员。

2. 如果静态成员函数声明与定义分离，static只需要写在声明处即可。

3. 除了可以使用对象调用外，还可以直接通过类名::调用，更加推荐后者。

#include <iostream>

using namespace std;

class Test
{
public:
    int a = 1;
    static int b;

    static void func(); // 静态成员函数
};

int Test::b = 1;

void Test::func() // 类外定义
{
//        cout << a << endl; 错误
    cout << b << endl;
}

int main()
{
    Test t;
    t.func();

    Test::func();

    return 0;
}

7.4 单例模式（了解）

模式设计（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。

单例 = 单实例

实例 instance = 对象 object

单例模式可以让类的对象全局创建时保持一个。

基于指针的单例模式（非完全版）：

#include <iostream>

using namespace std;

/**
 * @brief The Singleton class 单例模式的类
 */
class Singleton
{
private: // 构造函数私有化防止外部调用
    Singleton(){}
    Singleton(const Singleton&){}

    static Singleton* instance; // 类内的对象，即单例

public:
    static Singleton* get_instance()
    {
        if(instance == NULL)
            instance = new Singleton;
        return instance;
    }
};

Singleton* Singleton::instance = NULL;


int main()
{
    Singleton* s1 = Singleton::get_instance();
    cout << s1 << endl;
    Singleton* s2 = Singleton::get_instance();
    cout << s2 << endl;

    return 0;
}

基于引用的单例模式：

#include <iostream>

using namespace std;

/**
 * @brief The Singleton class 单例模式的类
 */
class Singleton
{
private: // 构造函数私有化防止外部调用
    Singleton(){}
    Singleton(const Singleton&){}

public:
    static Singleton& get_instance()
    {
        static Singleton instance;
        return instance;
    }
};

int main()
{
    Singleton& s1 = Singleton::get_instance();
    Singleton& s2 = Singleton::get_instance();
    cout << &s1 << " " << &s2 << endl;

    return 0;
}

8. const关键字

8.1 修饰成员函数（掌握）

const修饰的成员函数，表示常成员函数，可以调用非const的成员变量，但是不能修改数值，不能调用非const的成员函数。

如果常成员函数的声明与定义分离，const在声明和定义处都要使用。

#include <iostream>

using namespace std;

class Test
{
private:
    string name;
public:
    void set_name(string name)
    {
        this->name = name;
    }

    string get_name() const; // 常成员函数

    void test_const() const // 常成员函数
    {
//        set_name("哈哈哈"); 错误
        cout << get_name() << endl;
        cout << name << endl;
//        name = "你好"; 错误
    }
};

string Test::get_name() const // 类外定义
{
    return name;
}

int main()
{
    Test t;
    t.set_name("再见");
    t.test_const();

    return 0;
}

建议只要成员函数不修改属性值就使用const修饰，以提升代码的安全性，例如getter等。

8.2 修饰对象（掌握）

const修饰对象表示该对象是常量对象，这样的对象的成员变量数值不可变，不能调用任何非const修饰的成员函数。

#include <iostream>

using namespace std;

class Test
{
public:
//    string name = "张三"; // 直接初始化可以

    string name;

//    Test(string name)
//    {
//        this->name = name; // 构造函数函数体初始化可以
//    }

    Test(string name):name(name){}

    void set_name(string name)
    {
        this->name = name;
    }

    string get_name() const
    {
        return name;
    }
};



int main()
{
    // const可以放在类型前后
    Test const t1("张三");
//    t1.set_name("你好"); 错误
    const Test t2("李四");
//    t2.name = "你好"; 错误
    cout << t1.get_name() << endl;
    cout << t2.get_name() << endl;

    return 0;
}

8.3 修饰成员变量（掌握）

const修饰的成员变量表示常成员变量，这样的成员变量值不允许被修改。

常成员变量的初始化方式有两种：

  • 直接初始化
  • 构造初始化列表（优先级更高）
#include <iostream>

using namespace std;

class Test
{
public:

    const string name = "张三"; // 直接初始化

    Test(string name):name(name) // 构造初始化列表
    {}

//    Test(string name)
//    {
//        this->name = name; 错误
//    }

    void set_name(string name)
    {
//        this->name = name; 错误
    }

    string get_name() const
    {
        return name;
    }
};


int main()
{
    Test t("王五");
    cout << t.get_name() << endl;

    return 0;
}

8.4 修饰局部变量

表示局部变量不可被修改，常见于const修饰引用参数。

代码略。

8.5 constexpr 常量表达式（熟悉）

constexpr是比const更严谨的关键字，表示编译期确定的常量值。

#include <iostream>

using namespace std;

class Test
{
public:
    constexpr static int a = 1; // a=1在编译期确定
//    constexpr int b = 2; 错误
    const int c = 3;
};

在上面的例子中，a不需要配合任何对象使用，而对象是在程序运行期间创建的，因此a可以被constexpr修饰，表示在编译期确定；反之b需要在对象创建之后才能创建，因此不能被constexpr修饰。

被constexpr修饰的内容表示在编译期间可以确定，C++中部分代码是需要在编译期间确定。

#include <iostream>
#include <array> // 后面要学习的一个头文件

using namespace std;

// 表示是否可以在编译期间计算出返回值
constexpr int calc_len(int i)
{
    return i+5; // 随便写的计算规则
}

int main()
{
    // 5表示创建的arr对象的长度，必须在编译期间确定
    array<int,5> arr;

    // 编译期间可以计算出结果为6，正确
    array<int,calc_len(1)> arr2;

    int i = 1;
    // 编译期间无法计算出最后结果，报错
//    array<int,calc_len(i)> arr3; 错误

    return 0;
}

敲代码的鹏鹏
关注
cpp代码-（二维数组/字符串）将一组C++关键字存入二维数组，找出关键字中的最小者。
07-16
例如，我们可以声明一个二维数组`char keywords[10][10]`来存储长度不超过9个字符的C++关键字。 2. **字符串**：在C++中，字符串通常用字符数组来表示，如`char str[50]`。字符串的末尾通常用空字符`\0`来标记其...
C++关键字.doc
12-26
C++关键字的简单定义和一些概念的东西，希望通过对关键字的学习能更快的理解C++ 的基本语法。其中总结的不到位的地方希望看到的同学及时提醒，共同进步
C++ 关键字完整介绍
TENET123的博客
07-22 2043
C++ 关键字是编程语言保留的单词，这些单词具有特定的含义，并在编译过程中被编译器识别和处理。由于关键字有特殊的用途，因此不能将它们用作标识符（变量名、函数名、类名等）。
C++ 关键字
sihuachun的博客
12-24 978
C++关键字 alignas continue friend register true alignof decltype goto reinterpret_cast try asm default if return typedef auto delete inline short typeid bool do int signed typename break double long sizeof union case dynamic_cas...
C++关键字
nameofcsdn的博客
04-16 1153
。。
C/C++关键字整理
小子宝丁的博客
03-31 1358
本文共整理了C/C++关键字，其中C关键字32个，C++关键字97个。为了方便使用分别使用三种格式梳理。
C++关键字及其详解
热门推荐
随风@飘扬
03-03 3万+
C++关键字备注：图中是C++98/03中的63个关键字，红色标注的是C语言的32个关键字。C++11中有73个关键字，新增加的10个分别为：alignas、alignof、char16_t、char32_t、constexpr、decltype、noexpect、nullptr、static_assert、thread_local 下面是对部分关键字的解释： 一、数据类型相关 1、bool...
C++关键字noexcept
人无远虑，必有近忧
08-01 3050
C++17起： 规定noexcept是函数类型的一部分，并可以作为函数声明器的一部分出现。 C++17前： noexcept 规定不是函数类型的一部分（正如同动态异常规定），而且只能在声明函数、变量、函数类型的非静态数据成员、指向函数指针、到函数的引用或指向成员函数的指针时，和声明类型正好是指向函数指针或到函数的引用的参数或返回类型时，作为 lambda 声明器或顶层函数声明器的一部分出现。它不能出现于 typedef 或类型别名声明。 ———————————————— 版权声明：本文为CSDN博主「丸子叮
c++ 关键字和标识符
xinxin的博客
10-02 205
单词，对编译器具有特殊的含义。例如，示例int money;这里，int是一个关键字，表示money是整数类型的变量。这是所有C ++关键字的列表。（从C ++ 17开始）
C++关键字大全
weixin_59409001的博客
02-22 899
const（常量的，constant）所修饰的对象或变量不能被改变，修饰函数时，该函数不能改变在该函数外面声明的变量也不能调用任何非const函数。在 C++ 中，用 const 声明一个变量，意味着该变量就是一个带类型的常量，可以代替 #define，且比 #define 多一个类型信息，且它执行内链接，可放在头文件中声明；friend（友元）声明友元关系。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。
【C++ | 关键字】C++ 关键字介绍
wkd_007的博客
05-04 767
👉本文介绍C++的73个关键字，并介绍与C语言的32个关键字的区别，最后列出C++常用的关键字。
C++关键字入门（小白必看）
睡不醒的猫的博客
11-01 1052
详细讲述C++中除C语言的关键字，便于初学者更好了解C++这门语言。
c++关键字(精选)大全.docx
12-16
C++ 关键字大全 C++ 作为一门高效、灵活的编程语言，具有丰富的关键字集合，了解这些关键字的作用和用法是每个 C++ 开发者的必备技能。下面，我们将对 C++ 的关键字进行分类和解释，从基本数据类型到控制流语句，从...
C++关键字[全][定义].pdf
10-11
C++是一种强大的面向对象编程语言，其丰富的特性和关键字使得开发者能够创建高效且复杂的软件系统。本文将深入解析C++的关键字，主要关注其中的一些核心概念，帮助你更好地理解和应用这些关键字。 1. `asm`: 这个...
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1000
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 982
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 479
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
【C++】红黑树的封装——同时实现map和set
最新发布
Mesar的博客
09-27 367
学习map和set，深入了解底层，通过模拟实现，学习高效数据结构与容器的关系，也帮助我们更好了解和使用容器
c语言-数据类型
m0_69032433的博客
09-22 954
b --> 00000000 00000000 00000000 00001001 --> 9的原码,也是9的补码。... // 百度百科 https://baike.baidu.com/item/c%E8%AF%AD%E8%A8%80/105958?小数部分 1000 00000000 00000000 --> 1 * 2^(-1) --> 0.5。负整数的补码 --> -1 --> 取反 --> 绝对值的原码 --> 得到负数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值