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

C++学习笔记一

news 2025/7/5 7:53:31

C++学习笔记一

面向对象特性

C++是一种面向对象的编程语言，拥有面向对象开发的4个大特性

1. 封装：就像一个黑盒子一样，将数据和算法方法等封装到一起，对外只提供接口

2. 继承：其实就是代码的复用，并且对其中的属性和方法可以进行定制修改，代代相传

3. 多态：同一种操作作用于不同的对象，可以有不同的解释和实现。通过接口和继承来实现

4. 抽象：从具体的例子中提取共同的特征，从而形成抽象类和接口（底层）

标准库

C++有三个标准库

1. 核心语言，提供了所有构建块，包括常量，变量和数据类型等

2. C++标准库，提供了大量的函数

3. 标准模板库，提供了大量方法，示例等

基础语法

C++是一种对象的集合，这些对象通过调用彼此的方法进行交互

对象：对象具有状态和行为。比如一条鱼的颜色与动作等，是类的实例

类：描述对象的模板

方法：一种行为就代表一个方法，一个类可以包含多个方法

即时变量：每个对象有其独特的即时变量，对应对象的状态

C++简单程序结构

#include <iostream> //头文件iostream
using namespace std； //告知编译器使用std命名空间int main() //主函数，程序从这里开始执行
{ //语句块，使用大括号逻辑连接cout << "hello world"; //在屏幕上输出Hello worldreturn 0; //终止main函数，并向进程调用进程返回值0
}

C++数据类型

布尔型（bool）；字符型（char）；整型（int）；浮点型（float）；双浮点型（double）；无类型（void）；宽字符型（wchar_t（其实是短整型））；

一些基本类型可以采用修饰符进行修饰（常用）

派生数据类型

数组：相同元素的集合 int arr[5] = {1,2,3,4,5};

指针：存储变量内存地址的类型 int* ptr = &x;

用于表示指向对象为int的指针

引用：变量的别名 int& ref = x;

函数：函数类型，表示函数的签名 int func(int a , int b);

结构体：用户自定义的集合，可以包含不同类型的成员 struct point(int x ; int y;);

类：用户自定义的数据类型，支持继承，封装和多态。class myclass {. . .};

联合体：多个成员共享同一块内存 union Data {ini i ; float j;};

枚举：用户自定义的整数常量合集 enum color {red, green, blue};

关于枚举: enum color {red, green, blue} c;

c = red;

enum color {red, green=5, blue}，此时red=0，blue=6；

类型别名

typedef : 为现有类型定义别名 typedef int myint ;

using ：为现有类型定义别名 using myint = int ;

标准库类型

类型转换

C++中有四种转换：静态，动态，常量，重新解释转换；

静态转换（static cast）:将一种数据类型强制转换成相似的类型，但是不进行检查，运行易出错；

int i = 10;
float f = static_cast <float>(i);

动态转换（dynamic cast）：用于将一个基类（需具有虚函数）指针或引用转为派生类指针或引用

Base*ptr_base = new_Derived;
Derived*ptr_derived = dynamic_cast<Derived*>(ptr_base);

Base& ref_base = derived_obj;
Derived& ref_derived = dynamic_cast<Derived&>(ref_base)

常量转换（const cast）:用于将常量转为非常量，只能转换掉 const的属性，换不了类型

const int i = 10;
int& r const_cast<int&>(i);

重新解释转换（reinterpret cast）：用于转为不同数据类型的值，但是不进行检查

int i = 10;
float f = reinterpret_cast<float>(i);

C++变量类型

变量：程序可操作的存储区的名称。C++中有多种变量类型用来存储不同种类的数据,运算符可应用于变量上。

简单说，定义变量 int runoob_age = 20; 时，编译器会在内存（RAM）里找一块能存整数的空间（根据 int 类型确定大小），把这块空间用 “runoob_age” 当名字标记，然后把 20 放到这块空间里，后续代码要操作 runoob_age ，其实就是去访问这个地址对应的内存，读写里面存的 20 （或者后续可能被修改后的值）。

打个生活化比方，把内存想象成一个个带编号（地址）的储物格，runoob_age 是你给某个储物格起的好记名字（变量名就是地址的代表），20 是你放进这个储物格的东西，你通过喊 “runoob_age” ，就能找到对应的格子，拿到 / 修改里面的 “20” 啦，地址就是格子的编号，只是这里图里没显式写编号数值～

在函数声明时，提供一个函数名，则在任何地方都可以调用此函数

// 函数声明
int func();int main()
{// 函数调用int i = func();
}// 函数定义
int func()
{return 0;
}

在程序内部，局部变量与全局变量的定义可以一样，但是局部会把全局的数值覆盖掉。

std::用来指明命名空间的作用域解析运算符

C++常量

整数常量：整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

浮点常量：由整数部分、小数点、小数部分和指数部分组成。可以使用小数形式或者指数形式来表示浮点常量。当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时，必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

布尔常量：ture 和 false

字符常量：字符常量是括在单引号中。如果常量以 L（仅当大写时）开头，则表示它是一个宽字符常量（例如 L'x'），此时它必须存储在 wchar_t 类型的变量中。否则，它就是一个窄字符常量（例如 'x'），此时它可以存储在 char 类型的简单变量中。字符常量可以是一个普通的字符（例如 'x'）、一个转义序列（例如 '\t'），或一个通用的字符（例如 '\u02C0'）。

字符串常量：通常是括在“ ”中的，还有常量也是

常数常量：有两种方式：#define 和 const

#define width 13const int width 13

C++中的类型限定符

//const例子
const int NUM = 10; // 定义常量 NUM，其值不可修改
const int* ptr = &NUM; // 定义指向常量的指针，指针所指的值不可修改
int const* ptr2 = &NUM; // 和上面一行等价//volatile例子
volatile int num = 20; // 定义变量 num，其值可能会在未知的时间被改变//mutable例子
class Example {
public:int get_value() const {return value_; // const 关键字表示该成员函数不会修改对象中的数据成员}void set_value(int value) const {value_ = value; // mutable 关键字允许在 const 成员函数中修改成员变量}
private:mutable int value_;
};//static例子
void example_function() {static int count = 0; // static 关键字使变量 count 存储在程序生命周期内都存在count++;
}

C++存储类

auto类: auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

static存储类：指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。

extern存储类：提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当使用 'extern' 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

mutable类：用于修饰类的成员变量，使其能够在 const 成员函数中被修改。

#include <iostream>class Example {
public:Example() : value(0), cachedValue(0) {}// 常量成员函数int getValue() const {return value; // 读取常量成员}// 修改 mutable 成员void increment() {++value;cachedValue = value * 2; // 修改 mutable 成员}int getCachedValue() const {return cachedValue; // 读取 mutable 成员}private:int value;                 // 常规成员，不能在 const 函数中修改mutable int cachedValue;   // 可修改成员，可以在 const 函数中修改
};int main() {const Example ex;// ex.increment(); // 错误：无法在 const 对象上调用非 const 函数// ex.value = 10;  // 错误：无法修改 const 对象的成员std::cout << "Value: " << ex.getValue() << std::endl;std::cout << "Cached Value: " << ex.getCachedValue() << std::endl; // 输出为 0return 0;
}

适用场景：