深入浅出的C++Primer教程（第二章）

已于 2024-03-26 18:00:33 修改
阅读量924 收藏 28
点赞数 33
分类专栏： C++ 文章标签： c++ 开发语言
于 2024-03-26 14:15:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/particles/article/details/137017354
版权

2.1 基本内置类型

这一章我觉得应该在一开始就讲的，但是这本书放在了第二章，不过问题不大，我们需要了解这些我们一直在用的类型分别是什么。

2.1.2 算数类型

首先基础的类型如下表
算术类型
其中，主要分为bool：真（true）或者假（false），此时的bool不再是c语言中的BOOL是一个宏定义而是真真实实的数据类型；整型家族：short int long long long；浮点型家族float double long double和字符型char wchar_t char16_t char32_t等。

而在其它分类中，整形还能分为带符号的signed和无符号的unsigned，在一些代码中，不存在负数的情况可以选择无符号整型来实现更大的位宽，一般的，有符号数的前缀signed不需要写出来。

2.1.3 类型转换

注意：从这里开始就要注意了，含有无符号类型的表达式不能和有符号类型的变量混用，不然会出现异常。
举个例子

#include <iostream>
int main()
{
	int a = -20;
	unsigned int b = 10;
	std::cout << a + a << std::endl;
	std::cout << b + b << std::endl;
	std::cout << a + b << std::endl;
	return 0;
}

此时可以看到，前两个输出分别是-40和20很正常，但是第三个输出却不是-10，而是4294967286，这个数字哪里来的呢，其实是因为当整型和无符号整型相加的时候，会被类型转换为无符号整型，其中负号跟着的数就变成了在无符号整型中最大值-负号的数。

其他的自动类型转换还有类似于

#include <iostream>
int mian()
{
	int a = 0;
	double b = 1.12345;
	std::cout << a + b << std::endl;
	a = b;
	std::cout << a << std::endl;
	return 0;

此时第一个输出是正常的1.12345，因为在相加时会自动将简单类型转化为复杂类型。
自动类型转换
但是当你把一个高精度的数据写入低精度的数据，虽然不会报错，但是会损失精度

2.1.3 字面值常量

一个形如42的值被称作字面值常量 (literal) 这样的值一望而知。每个字面值常量都对应一种数据类型，字面值常量的形式和值决定了它的数据类型。
这一节讲的很晦涩难懂，我们不去看他的书面解释，用自然语言来理解就是，你看的见的值叫字面值，如果他不是变量（不可改变）则为常量。
举个例子a = 20，其中，20就是字面值常量，又或者"Hello,World!"也是一个字符串型的字面值常量，此时要注意几种字面值常量的写法。

字面值常量类型写法
整型（10进制数）直接写
整型（8进制数）在前面加0（如012就是8进制中的10）
整型（16进制数）在数字前加0x
整型（2进制数）在数字前加0b
字符型用单引号’'包裹
字符串型用双引号""包裹

其中，字符类型和字符串类型最大的区别是，字符串类型会在结尾补一个空字符\0, 因此，字符串字面值的实际长度要比它的内容多1。

2.1.4 转义序列

这个直接看表，用过C语言就会知道了。
转义序列

2.1.5 指定字面值的类型

这个也没什么好说的，看表
在这里插入图片描述

2.2 变量

变量提供一个具名的、可供程序操作的存储空间。C++中的每个变量都有其数据类型，数据类型决定着变量所占内存空间的大小和布局方式、该空间能存储的值的范围，以及变量能参与的运算。对C++程序员来说“变量(variable)”和“对象(object)”一般可以互换使用。

2.2.1 变量的定义

一般的，变量由这几部分组成：变量类型 变量名 （可以一个或多个以逗号隔开）变量初始化值（以=初始化）分号结束
其中有个小知识很有意思
何为对象

变量初始化

虽然变量初始化和赋值都是用=，但是其意义不同，赋值是指使用一个值覆盖原有值，初始化是为一个没有值的变量创造一个值。

默认初始化

如果定义变量时没有指定初值，则变量被默认初始化 (default initialized)，此时变量 被赋予了 “默认值”。默认值到底是什么由变量类型决定，同时定义变量的位置也会对此有影响。
如果是内置类型的变量未被显式初始化，它的值由定义的位置决定。定义于任何函数体之外的变量被初始化为0。

又到了小故事时间
未初始化变量可能引发故障

2. 2. 2 变量声明和定义的关系

为了允许把程序拆分成多个逻辑部分来编写，C+语言支持分离式编译 (separate compilation)机制，该机制允许将程序分割为若干个文件，每个文件可被独立编译。

为了支持分离式编译，C++语言将声明和定义区分开来。声明(declaration)使得名字为程序所知，一个文件如果想使用别处定义的名字则必须包含对那个名字的声明。而定义 (definition )负责创建与名字关联的实体。

如果想声明一个变量而非定义它，就在变量名前添加关键字extern，而且不要显式地初始化变量

#include<iostream>
int main()
{
	extern int j;//声明j
	int i;//声明并定义i
	return 0;
}

注意：

  1. 任何包含了显式初始化的声明即成为定义。
  2. 在函数体内部，如果试图初始化一个由extern 关键字标记的变量，将引发错误。
  3. 变量能且只能被定义一次，但是可以被多次声明

这里补充一个关键点
静态类型

2.2.3 标识符

C++ 的标识符 (identifier) 由字母、数字和下画线组成，其中必须以字母开头。标识符的长度没有限制，但是对大小写字母敏感。

变量命名规范
  1. 标识符号要体现其实际意义
  2. 变量名首字母尽量用小写字母
  3. 用户自定义类名首字母一般大写
  4. 如果标识符由多个单词组成则其单词与单词之间的区分应该更加明显
  5. 变量名不能与保留字冲突
    c++关键字及其操作符替代名

2.2.4 名字的作用域

首先我们要了解作用于的概念
作用域(scope)是程序的一部分，在其中名字有其特定的含义 。C++语言中大多数作用域都以花括号分隔。
同一个名字在不同的作用域中可能指向不同的实体。名字的有效区域始于名字的声明语句，以声明语句作用域的末端为结束。

全局作用域

名字main 定义于所有花括号之外，它和其他大多数定义在函数体之外的名字一样拥有全局作用域 (global scope)。一旦声明之后，全局作用域内的名字在整个程序的范围内都可使用。

块作用域

其他的名字定义在main中或者其他函数中，它的生命周期就随着main或者其他函数的声明而开始，以其声明的作用域结束而结束。

嵌套的作用域

作用域能彼此包含，被包含(或者说被嵌套)的作用域称为内层作用域(innerscope)，包含着别的作用域的作用域称为外层作用域(outerscope)。
作用域中一旦声明了某个名字，它所嵌套着的所有作用域中都能访问该名字。同时，允许在内层作用域中重新定义外层作用域已有的名字

示例程序

#include <iostream>
int main()
{
	int a = 1;
	for(int i = 1 ;i < 10;i++)
	{
		int a = i;
		std::cout << a << std::endl;
	}
	std::cout << a << std::endl;
	return 0;
}

此事可以看到循环内的a输出1到9，但是循环外的a还是输出1，这说明一件事，就是循环内对循环外声明的值赋值不会作用到循环外。

2.3 复合类型

2.3.1 引用

写在前面哈，c11确实有另外一种引用（右值引用），本章不做说明，在后续C11中会细讲。
引用说成人话就是给变量起别名，原理很像是定义宏。
一般在初始化变量时，初始值会被拷贝到新建的对象中。然而定义引用时，程序把引用和它的初始值绑定(bind)在一起，而不是将初始值拷贝给引用。一旦初始化完成，引用将和它的初始值对象一直绑定在一起。因为无法令引用重新绑定到另外一个对象，因此引用必须初始化。
几个特点记一下

  1. 为引用赋值本质上就是为原对象赋值
  2. 引用本身不是一个对象，因此无法生成引用的引用
  3. 允许在一条语句中定义多个引用，但是必须以&开头

示例代码

#include <iostream>
int main()
{
	int a = 1;
	int &b = a;
	b = 10;
	std::cout << a << std::endl;
	return 0;
}

2.3.2 指针

这个是重中之重！c++很多特性都是依靠它运作的！
看看书中的巨大感叹号
在这里插入图片描述
就可以看出指针是多么重要了
指针(pointer)是“指向(pointto)”另外一种类型的复合类型。与引用类似，指针也实现了对其他对象的间接访问。然而指针与引用相比又有很多不同点。其一，指针本身就是一个对象，允许对指针赋值和拷贝，而且在指针的生命周期内它可以先后指向几个不同的对象。其二，指针无须在定义时赋初值。和其他内置类型一样，在块作用域内定义的指针如果没有被初始化，也将拥有一个不确定的值。
定义指针类型的方法将声明符写成*d的形式，其中d是变量名。如果在一条语句中定义了几个指针变量，每个变量前面都必须有符号*
指针存放某个对象的地址，要想获取该地址，需要使用取地址符(操作符&)
指针的值(即地址)应属下列4种状态之一:

  1. 指向一个对象。
  2. 指向紧邻对象所占空间的下一个位置。
  3. 空指针，意味着指针没有指向任何对象。
  4. 无效指针，也就是上述情况之外的其他值。

试图拷贝或以其他方式访问无效指针的值都将引发错误。编译器并不负责检查此类错误，这一点和试图使用未经初始化的变量是一样的。访问无效指针的后果无法预计，因此程序员必须清楚任意给定的指针是否有效。

可能同学们还听过另一个词叫“野指针”，这又是什么东西呢
野指针（dangling pointer）是指指向已经释放或者无效的内存地址的指针。在程序中，当一个指针被分配了一块内存空间，然后这块内存被释放或者释放后重新分配给其他变量，但原指针并未修改，此时这个指针就成为了野指针。
野指针的存在可能导致程序崩溃、数据损坏或者未定义的行为，因为它们可能会导致对无效内存地址的访问（本质上就是一个无效指针）。
如果指针指向了一个对象，则允许使用解引用符(操作符)来访问该对象*
做一个小拓展
某些符号有多重含义
空指针(nullpointer)不指向任何对象，在试图使用一个指针之前代码可以首先检查它是否为空。
说到空指针，就得说一下空指针的制作方法。

#include <cstdlib>
int main()
{
	int *p = nullptr;
	int *q = NULL;
	return 0;
}

nullptr又是一个C11的新特性，它允许将被转化成各种类型的空指针，而NULL则由cstdlib头定义，它本质上就是一个为0的宏
这是书中给出的建议
初始化所有指针

赋值和指针

指针和引用都能提供对其他对象的间接访问，然而在具体实现细节上二者有很大不同，其中最重要的一点就是引用本身并非一个对象。一旦定义了引用，就无法令其再绑定到另外的对象，之后每次使用这个引用都是访问它最初绑定的那个对象。指针和它存放的地址之间就没有这种限制了。和其他任何变量(只要不是引用)一样，给指针赋值就是令它存放一个新的地址，从而指向一个新的对象。

void*指针

void*指针可以存储任何变量类型的地址，但是我们不能直接操作void*指针所指的对象，因为我们不清楚里面是什么东西

2.3.3 理解复合类型的声明

这一部分是最容易令人头大的部分，常见的复合对象有：指针的指针，指针的引用，到后面可能还有指针函数，函数指针，指针常量，常量指针等，本章中只讲指针的指针，指针的引用这两点。

指针的指针

这个很简单，让阿妮娅来教你双重指针

很简单嘛，指针的指针就是指向另一个指针的指针
一个demo

#include<iostream>
int main()
{
	int a = 20;
	int *p = &a;
	int **q = &p;
	std::cout << "q:" << q << " &p:" << &p << std::endl << "*q:" << *q << " p:" << p << " &a:" << &a << std::endl << "*p:" << *p << " a:" << a << std::endl;
	return 0;
}

看输出
输出
可以很容易理解指针的指针，指针，和指针指向对象的关系
指针的指针存的值是指针的地址，指针的指针指向的值是指针的值是指针指向变量的地址。

指针的引用
#include <iostream>
int main()
{
	int i = 1;
	int *p;
	int *&r = p;
	r = &i;
	std::cout << *p <<std::endl;
	return 0;
}

此时给r赋值i的地址就是给p指向的对象赋值，因此输出1。

2.4 const限定符

这个没啥好说的，就是常量，但是不意味着他就什么都干不了，大多数运算，转换都是可以的（只要不改变其值）

#include <iostream>
int main()
{
	const int a = 12;
	int b = a;
	std::cout << a + 10 << std::endl;
	std::cout << b << std::endl;
	return 0;
}

注意：

  1. const限定的对象必须初始化
  2. 默认状态下const对象仅在文件内有效，如果我们想让这类const 对象像其他（非常量）对象一样工作，也就是说，只在一个文件中定义const ，而在其他多个文件中声明并使用它。如果想只定义一次，只需要对于const 变量不管是声明还是定义都添加extern 关键字就可以了。

2.4.1 对const的引用

可以把引用绑定到const对象上，就像绑定到其他对象上一样，我们称之对常量的引用(referencetoconst)。与普通引用不同的是，对常量的引用不能被用作修改它所绑定的对象
术语

初始化和对const的引用

当声明一个对const的引用时，有以下几个要点需要注意：

  1. 初始化：对const的引用必须在声明时进行初始化。这是因为引用一旦被声明，就必须指向一个已经存在的对象。初始化确保了引用在声明时就有一个有效的目标对象。

  2. 类型匹配：引用的类型必须与其引用的对象的类型相匹配。对于const引用，这意味着你不能将一个非常量类型的对象引用为const类型，反之亦然。但是，可以将一个const对象引用为一个非const类型，只要不通过这个引用修改对象。

  3. 常量引用的初始化：对于常量引用，C++允许使用任意表达式作为初始值，只要这个表达式的结果可以转换成引用的类型。这意味着你可以将一个非常量对象、字面值或任何表达式绑定到一个const引用上。编译器会隐式地创建一个临时对象（临时量），并将这个临时对象绑定到引用上，而不是直接绑定到原始表达式。

  4. 尽管const引用本身不允许修改其指向的对象，但对象本身可能是可修改的。这意味着你可以通过其他非const引用或直接对对象进行修改。

下面是一些示例：

#include <iostream>
int main()
{
	const int &r1 = i; // 允许将const int&绑定到一个普通int对象上
	const int &r2 = 42; // 正确：r2是一个常量引用，绑定到字面值42
	const int &r3 = r1 * 2; // 正确：r3是一个常量引用，绑定到r1 * 2的结果
	int &r4 = r1 * 2; // 错误：r4是一个普通的非常量引用，不能绑定到临时量
	
	int i = 42;
	int &r1 = i;
	const int &r2 = i;
	r1 = 0; // 通过非常量引用修改i的值
	r2 = 0; // 错误：尝试通过常量引用修改i的值
	
	return 0;
}

2.4.2const指针

常量指针(constpointer)必须初始化，而且一旦初始化完成，则它的值(也就是存放在指针中的那个地址)就不能再改变了。把*放在const关键字之前用以说明指针是一个常量，这样的书写形式隐含着一层意味，即不变的是指针本身的值而非指向的那个值
于是我们就可以理解为，常量指针，指针本身不变，但是指向的值可变。

#include <iostream>
int main()
{
	int i = 200;
	int *const p = &i; 
	*p = 10;
	std::cout << *p <<std::endl;
	return 0;
}

2.4.3 顶层const和底层const

顶层const如前所述，指针本身是一个对象，它又可以指向另外一个对象。因此，指针本身是不是常量以及指针所指的是不是一个常量就是两个相互独立的问题。用名词顶层const(top-levelconst)表示指针本身是个常量，而用名词底层const(low-levelconst)表示指针所指的对象是一个常量。

听起来是不是很复杂，但其实这与指针常量和常量指针的概念相似。
简单来说，顶层 const 表示被 const 修饰的对象本身是常量，而底层 const 表示被 const 修饰的对象所指向/引用的值是常量。
因此，顶层 const 可以是任何类型的常量，而底层 const 通常涉及指针或引用。

举个例子

#include <iostream>

int main() {
    int x = 10;
    const int* ptr1; // ptr是一个指向常量整数的指针

    ptr1 = &x; // 允许，可以改变指针所指向的地址
    std::cout << *ptr1 << std::endl; // 输出 10，可以读取指针指向的对象的值

    // *ptr1 = 20; // 错误！无法通过ptr修改所指向的整数的值，因为ptr指向的对象是常量

	int* const ptr2 = &x; // ptr是一个指向整数的常量指针

    // ptr2 = &y; // 错误！无法改变指针本身的地址

    *ptr2 = 20; // 允许，可以通过ptr修改所指向的整数的值
    std::cout << *ptr2 << std::endl; // 输出 20，可以读取指针指向的对象的值

    return 0;
}

2.4.4 constexpr和常量表达式

常量表达式(constexpression)是指值不会改变并且在编译过程就能得到计算结果的表达式。显然，字面值属于常量表达式，用常量表达式初始化的const对象也是常量表达式。

constexpr变量

在C11的标准下，允许将变量声明为constexpr类型以便由编译器来验证变量的值是否是一个常量表达式。声明为constexpr的变量一定是一个常量，而且必须用常最表达式初始化

指针和constexpr

在constexpr声明中如果定义了一个指针，限定符constexpr仅对指针有效，与指针所指的对象无关

2.5 处理类型

2.5. 1 类型別名

它的作用是生成一个某种类型的同义词，传统的方法是使用关键字typedef，比如

typedef double wages; //wages是double的同义词
typedef wages base, *p; //base是double的同义词，p是double*的同义词

新标准规定了一种新的方法，使用别名声明(aliasdeclaration)来定义类型的别名

usingSI = Sales_item; //SI是Sales_item的同义词

有人会觉得，这不是脱裤子放屁吗，但是显然，他在某些情况尤其好用，比如我们在定义字符数组char*时，我们使用typedef char* pstring语句将其取了个pstring的别名，这样当我们在调用pstring的时候本质上就在调用char*。

很多人会想了，那这个和define有什么区别，首先define时宏定义，不止可以定义类型，还可以定义类数字，字母等
typedef定义的别名会进行类型检查，因为他被认作原类型的别名，而define只会简单替换而不触发类型检查

2.5.2 auto类型说明符

这一章我原本以为会一起拖到c11专题的时候讲，没想到这个时候就引出来了。
首先，auto我们从字面意思上可以理解为一个自动的类型，它能根据你给这个变量的赋值来确定变量类型。
举个例子 如果我输入auto a = 0;此时a的类型会因为0而变成int。
这里就要引入第一个知识点了，auto类型的变量定义的时候必须赋值，如果不赋值会报错未提供初始值。
第二个知识点是，auto的用法也可以和其他数据类型一样，一行定义多个变量，但必须是一个类型的。
举个例子

#include <iostream>
int main()
{
	auto a = 1 , *b = &a;
	auto d = 1 , e =2.2;
	return 0;
}

在这种情况下，第一个auto被成功赋值，因为*和&都是从属于某个声明符，基础数据类型还是int但第二个一个是整型一个是浮点型。
第三个是上篇讲过的顶层const和底层const的拷贝
如果是顶层const（本身元素是常量）在用auto进行拷贝的时候会默认忽略其const属性；而如果想让其具有常量属性，则需要用底层const。
我知道这看起来很懵圈，下面举一个例子你就明白了。

#include <iostream>
int main()
{
	const int a = 1; // 顶层 const
	auto b = a;
	b = 2;
	std::cout << b << std::endl;

	const auto* ptr = &a; // ptr 是一个指向常量 int 的指针（底层 const）
	// *ptr = 5; // 这里尝试通过 ptr 修改所指向的值会编译错误，因为 *ptr 是一个底层 const
	return 0;
}

2.5.3 decltype类型指示符

这个也是C11独有的，和上面的auto相辅相成，如果你无法确定一个函数的返回值类型，但是你却需要接收这个函数的返回值作为计算对象应该怎么办呢？一种方法是直接用上文的auto，使接收函数类型自动计算，第二种方法就是decltype了。

它的用法是：decltype(fun ()) 函数名 其中，该函数的函数类型就是fun()的返回值类型

而在处理顶层const方面：decltype处理项层const和引用的方式与auto有些许不同。如果decltype使用的表达式是一个变量，则decltype返回该变量的类型(包括项层const和引用在内)。
需要指出的是，引用从来都作为其所指对象的同义词出现，只有用在decltype处是一个例外。
如果decltype使用的表达式不是一个变量，则decltype返回表达式结果对应的类型。
另一方面，如果表达式的内容是解引用操作，则decltype将得到引用类型。正如我们所熟悉的那样，解引用指针可以得到指针所指的对象，而且还能给这个对象赋值。
decltype和auto的另一处重要区别是，decltype的结果类型与表达式形式密切相关。有一种情况需要特别注意:对于decltype所用的表达式来说，如果变量名加上了一对括号，则得到的类型与不加括号时会有不同。如果decltype使用的是一个不加括号的变量，则得到的结果就是该变量的类型:如果给变量加上了一层或多层括号，编译器就会把它当成是一个表达式。变量是一种可以作为赋值语句左值的特殊表达式，所以这样的decltype就会得到引用类型。
举个例子

#include <iostream>

int main() {
    int x = 5;
    decltype((x)) y = x; // 声明一个引用y，类型是变量x的引用类型
    decltype(x) &z = x; // 声明一个与变量x类型相同的引用y
    y = 10; // 修改y也会修改x的值
    std::cout << "x: " << x << std::endl; // 输出为10
    return 0;
}

此处y和z都是引用，不同的是，因为(x)是有括号的被视作表达式因此传递的就是引用了。

2.6 自定义数据结构

从最基本的层面理解，数据结构是把一组相关的数据元素组织起来然后使用它们的策略和方法。C++语言允许用户以类的形式自定义数据类型，而库类型 string、 stream 、ostream 等也都是以类的形式定义的。

这个我觉得这一章节讲还是过于早了，但是不妨碍我们稍作了解。
几个关键的点我提一下

  1. 一般来说，最好不要把对象的定义和类的定义放在一起。这么做无异于把两种不同实体的定义混在了一条语句里，一会儿定义类，一会儿又定义变量，显然这是一种不被建议的行为。
  2. 很多新手程序员经常忘了在类定义的最后加上分号（这条在书中是被加上⚠️标识的）
  3. C++11新标准规定，可以为数据成员提供一个类内初始值(in-class initializer)。创建对象时，类内初始值将用于初始化数据成员。没有初始值的成员将被默认初始化
  4. 为了确保各个文件中类的定义一致，类通常被定义在头文件中，而且类所在头文件的名字应与类的名字一样。
  5. 头文件一旦改变，相关的源文件必须重新编译以获取更新过的声明。

这里还涉及到一个点叫预处理器：
确保头文件多次包含仍能安全工作的常用技术是预处理器(preprocessor)，它由C++语言从C语言继承而来。预处理器是在编译之前执行的一段程序，可以部分地改变我们所写的程序。之前已经用到了一项预处理功能#include，当预处理器看到#include标记时就会用指定的头文件的内容代替#include。
C++程序还会用到的一项预处理功能是头文件保护符(headerguard)，头文件保护符依赖于预处理变量。预处理变量有两种状态:已定义和未定义。#define指令把一个名字设定为预处理变量，另外两个指令则分别检查某个指定的预处理变量是否已经定义:#ifdef当且仅当变量已定义时为真，#之Endef当且仅当变量未定义时为真。一旦检查结果为真，则执行后续操作直至遇到#endif指令为止。使用这些功能就能有效地防止重复包含的发生。
结构如下

#ifndef 类名_H
#define 类名_H
类实现
#endif  类名_H

在新版本中，为了防止头文件被重复定义，我们可以使用更加新的函数#pragma once也能有一样的效果。

写在后面

终于写完了，没想到这一次第二章写了我一万两千字，两天才整理完，当然，这也意味着这一章节对于后面几节尤为重要，类型是c++的基础，大家要多加练习。
在最结尾处，同学们可以考虑使第一章我让你们做的计算器具备小数计算（浮点运算）和除法功能，并封装成类可以被其他类调用。

可能是阿伦
关注
专栏目录
《深入浅出LLM基础篇》（四）：主流大模型介绍
专注大数据与人工智能技术分享，欢迎私信加群互相学习！
05-13 1175
本篇为《深入浅出LLM基础篇》系列第四篇，《深入浅出LLM基础篇》（四）：主流大模型分类介绍主流大模型分类，主要讨论各类模型结构组成、模型特点、数据规模等进行介绍，包括 ChtaGLM、LLAMA等 系列，最后对经典问题进行总结，方便大家交流学习。
深入浅出的c++教程（基于C++Primer）第一章
particles的博客
03-25 823
这份教程严格意义上来说是我学习C++Peimer这本书的时候的感悟和经验，其中章节排布以及示例会尽量贴近这本书，因此，在观看本教程时建议边看这本书以加深理解，如果需要电子版可以点击这里自取电子版C++Primer及课后题答案，希望各位同学看完本教程能对c++有更深层次的了解。这一章很奇怪，如果是我的话应该会放到后面和类一起讲，但是为了和书中讲述的知识点相匹配，我们还是根据书中的知识讲。首先，当我们需要了解类是个什么玩意儿，在C++中，我们通过定义一个类(class)来定义自己的数据结构。
深入浅出的C++Primer教程（第六章）函数
particles的博客
07-03 557
（0个或多个）及组成，我们最开始写的helloworld就可以看做是一个函数（主函数）。其中int是函数返回值类型，main是函数名，花括号中间是函数体，该函数形参为空。
【重学c++primer】第五章第二节 深入浅出：左值和右值
qq_51931826的博客
08-18 977
【重学c++primer】第五章第二节 深入浅出：左值和右值
【重学c++primer】第二章 深入浅出：变量的类型
qq_51931826的博客
04-27 1135
char是否有符号：影响可移植性整数在内存中的保存方式：大端和小端，影响可移植性每种类型的大小：影响可移植性特别的，unsigned和unsigned int是等价的，因为int太常用了。
深入浅出的C++Primer教程（第四章）
particles的博客
03-27 757
表达式的组成：表达式由运算对象（operand）和运算符（operator）组成。运算对象可以是字面值、变量或者是更复杂的表达式。运算符用于指定如何对运算对象进行操作。运算符类型一元运算符：作用于单个运算对象的运算符，例如取地址符（&）和解引用符（*）。二元运算符：作用于两个运算对象的运算符，例如相等运算符（==）和乘法运算符（*）。三元运算符：作用于三个运算对象的运算符，C++中唯一的三元运算符是条件运算符（?:）。函数调用：也是一种特殊的运算符，对运算对象的数量没有限制。运算符优先级和结合律。
深入浅出的C++Primer教程（第三章）
particles的博客
03-26 1249
字符串和向量和数组
【重学c++primer】第四章第三节 深入浅出：从数组到指针
qq_51931826的博客
08-18 1061
上述的第二个例子企图使用数组会隐式转换成指针来完成数组的声明，这样在source.cpp文件中，即使更改了数组的下标，在main.cpp中也不需要更改，可以小偷懒。然后，由于在main.cpp文件里，a被视为一个指针，在64位操作系统下，指针占8个字节，因此读取出来的数组为：01 00 00 00 02 00 00 00。比如上面的例子， a的类型是int[3]， 但是b的类型是int*, 其中丢失的信息就是3， 3的含义就是元素的个数为3。
深入浅出的C++Primer教程（第五章）语句
particles的博客
03-27 612
没想到这么快就到了第五章。
C++Primer第四版课后答案
07-10
《C++ Primer第四版》是C++编程领域的一本经典教材，它深入浅出地介绍了C++语言的基础知识和高级特性。本资源包含了该书第四版的第2、7、10章的课后习题答案，每个章节的习题解答以可运行的程序形式提供，这对于学习...
C++ Primer(第四版)第二章、第三章部分习题源代码
09-18
《C++ Primer(第四版)》是学习C++编程的经典教材，它深入浅出地介绍了C++语言的基础和高级特性。本压缩包包含了该书第二章和第三章的部分习题的源代码，这些代码旨在帮助读者更好地理解和掌握C++语言的基本概念和...
c++primer 第五版 2-7章答案（本人整理 亲测有效
06-03
这本书深入浅出地介绍了C++语言的基础和高级特性，适合初学者和有一定经验的程序员作为学习参考。本压缩包包含的是作者整理的第二至第七章的习题解答，每章一个PDF文件，分别为： 1. **第二章答案**：这一章主要...
C++Primer第二章例题及练习题答案源代码
05-08
解压缩后，你会看到两个文件夹，分别对应“C++Primer第二章练习题”和“C++Primer第二章例题”。每个文件夹中的源代码文件（通常是.cpp格式）都包含了书中例题或练习题的实现。通过阅读和运行这些代码，你可以看到...
PyQt 的Tree Widget中拖放和点击的异常行为
weixin_44617651的博客
10-10 472
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
c_cpp_properties.json文件的作用
最新发布
程序员黄老师的精品课！
10-10 247
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
【C++】List
m0_46676283的博客
10-08 434
文章目录1.list的介绍及使用1.1 list的介绍 本节目标 1.list的介绍及使用 2.list的深度剖析及模拟实现 3.list与vector的对比 4.本节习题 1.list的介绍及使用 1.1 list的介绍
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 997
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
C++ Primer中文第四版全章习题答案详解
《C++ Primer（第4版）》是一本经典的C++编程教材，该书深入浅出地介绍了C++语言的基础知识和高级特性。中文第四版不仅提供了丰富的理论内容，还包含了大量习题和解答，旨在帮助读者通过实践巩固理论学习。这份资源...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值