cpp primer笔记-010开始

原创 已于 2023-10-06 16:18:22 修改 · 156 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++

于 2023-10-06 15:13:36 首次发布
博客围绕C++编程展开，介绍了char类型使用时需明确有符号或无符号，避免有符号和无符号类型混用计算。还阐述了泛化转义序列规则，以及void*指针、引用、const、constexpr的特性和使用注意事项。此外，提及了类型别名、auto、decltype的要点，以及string、vector、迭代器的使用规则。
  1. 下面的第5行代码可以写成第6行注释的代码
    #include<iostream>
int main()
{
	int v1{}, v2{};
	(std::cin >> v1) >> v2;
	//std::cin>>v1>>v2;
	(std::cout << v1) << " " << v2 << std::endl;
	return 0;
}
  2. char类型在有些机器上是有符号的，在有些机器上是无符号的，需要使用char类型，最好明确是signed char还是unsigned char.
  3. 当赋给无符号类型一个超出其表示范围的值是，得到的结果是初始值对无符号类型表示数值总数取模后的余数，但是赋给有符号类型一个超出其表示范围的值，结果是未定义未知的，程序可能继续工作，可能崩溃，也可能产生垃圾数据。如果一个表达式中包含有符号和无符号类型，则有符号类型会转换成无符号类型进行计算，切勿混用带符号和无符号类型进行计算。
    #include<iostream>
#include <climits>
int main()
{
    unsigned u = 10, v = 42;
    int i = -42;
    long long l = i + 10, num = UINT32_MAX + 1LL, g = i * 10;
    std::cout << u - v << " " << u + i << " " << u * i << std::endl;
    std::cout << (l + num) % num << " " << (g + num) % num << std::endl;
    return 0;
}

    4294967264 4294967264 4294966876
4294967264 4294966876
  4. 使用泛化的转义序列，其形式是\x后紧跟着1ge或者多个16进制数字，或者\后紧跟着1个或者多个八进制数组其中数字部分表示的是字符对应的数值,如果\后面跟着的八进制数组超过3个，则只有前面三个数字与\构成转义序列，如果\x跟着的十六进制数超过4个，则只有前面4个数组与\构成转义序列。
    #include<iostream>
#include <climits>
int main()
{
    int num = ' ';
    std::cout << std::hex;
    std::cout << num << std::endl;
    std::cout << '\x20' << '\12' << "234" << std::endl;
    return 0;
}

    20

234
  5. void可以存放任意对象的地址，包括另一个指针所指向的地址，但是void的作用比较有限，只能拿它和别的指针比较，作为函数输入输出，或者给另外一个void指针赋值，但是不能直接操作void类型的指针所指向的对象。除了void*是个例外，其他大部分情况下指针的类型和指向的对象类型要严格匹配，不发生隐式类型转换。
    #include<iostream>
#include <climits>
int main()
{
	double num = 3.14, * pd = &num;
	void* pv = &num;
	pv = pd;
	std::cout << *pd << " " << *(double*)(pv) << std::endl;
}
  6. 引用本身不是一个对象，所以不能定义一个指向引用的指针，但是指针是对象，所以可以存在对指针的引用。
    #include<iostream>
#include <climits>
int main()
{
	int i = 42;
	int* p;
	int*& r = p;
	r = &i;
	*r = 1;
	std::cout << i << " " << *p << " " << *r << std::endl;
}
  7. const修饰的对象仅在定义文件内有效，非定义文件不存在该对象，如果想在其他文件一并使用，则对const变量不管是声明还是定义都加上extern关键字，这样只需要定义一次就够了，常变量引用初始化的时候可以使用任意表达式作为初始值。如果const引用的不是一个const的对象，则该对象可以通过另一个非const引用改变值，也可以通过自身改变值，但是不能通过const引用改变值
    //file.cc文件定义并初始化一个常变量，该常变量能够被其他文件使用
extern const int bufSize=fuc();
//file.h头文件
extern const int bufSize;//和file.cc文件定义的bufSize是同一个
double dval=3.45;
int a=43,b=34;
//允许任意表达式作为初始值
const int &ri=a+b;
//允许由双精度浮点数生成一个临时的整形变量
const int &rp=dval;
//允许常变量引用初始化值是常量
const int& int_ptr = 10;

    #include<iostream>
#include <climits>
int main()
{
	int i = 42;
	int& r1 = i;
	const int& r2 = i;
	std::cout << r1 << " " << r2 << " " << i << std::endl;
	r1 = 1;
	std::cout << r1 << " " << r2 << " " << i << std::endl;
	i = 2;
	std::cout << r1 << " " << r2 << " " << i << std::endl;
}

    42 42 42
1 1 1
2 2 2
  8. constexpr可以类型必须用常量表达式初始化，一个constexpr指针的初始值必须是nullptr或者0，或者储存于某个固定地址的对象(比如函数体外)
    #include<iostream>
#include <climits>
//x必须定义在函数体外才能被consrexpr修饰
int x = 10;
int main()
{
	const int a = 10;
	constexpr int b = 20;
	constexpr int c = a + b;
	//p1是指向整形常量的指针，
	const int* p1 = nullptr;
	//p2是指向整形的常量指针
	constexpr int* p2 = 0;
	//p3是指向整形常量的常量指针
	constexpr const int* p3 = &x;
	//p4是指向整形的常量指针
	constexpr int* p4 = &x;
	p1 = &b;
	*p4 = 20;
	std::cout << *p1 << " " << p2 << " " << *p3 << " " << *p4 << std::endl;

}

  1. CPP允许给类型起别名，包括使用typedef和using，注给指针起别名的时候使用const修饰的指针是常量指针，而不是指向常量的指针。

    #include<iostream>
#include <climits>
int main()
{
	typedef double wages;
	typedef wages base, * p;
	base i = 1.0;
	const p ptr = &i;
	//相当于double * const ptr = &i;
	*ptr = 20;
	std::cout << i << " " << *ptr << std::endl;
	double* const num = &i;
	*num = 30;
	using Son = int;
	Son s = 10;
}

  2. auto一般会忽略掉顶层的const，不能将类型变成指向数据的常量指针，但是能够变为指向常量的指针,如果希望变出来的数据能够是指向数据的常量指针，则可以在auto左边加上const

    	#include<iostream>
	#include <climits>
	#include<typeinfo>
	int main()
	{
		int i = 10;
		const int ci = i, & cr = ci;
		auto a = i;
		auto b = ci;
		auto c = cr;
		auto d = &i;
		auto e = &ci;
		const auto f = ci;
		auto& g = ci;
		const auto& j = 42;
		auto& m = ci, * p = &ci;
		const auto* x = &ci;
		std::cout << "a " << typeid(a).name() << std::endl;
		std::cout << "b " << typeid(b).name() << std::endl;
		std::cout << "c " << typeid(c).name() << std::endl;
		std::cout << "d " << typeid(d).name() << std::endl;
		std::cout << "e " << typeid(e).name() << std::endl;
		std::cout << "f " << typeid(f).name() << std::endl;
		std::cout << "g " << typeid(g).name() << std::endl;
		std::cout << "j " << typeid(j).name() << std::endl;
		std::cout << "m " << typeid(m).name() << std::endl;
		std::cout << "p " << typeid(p).name() << std::endl;
		std::cout << "x " << typeid(x).name() << std::endl;
	}
	```
```cpp
a int
	b int
	c int
	d int * __ptr64
	e int const * __ptr64
	f int
	g int
	j int
	m int
	p int const * __ptr64
	x int const * __ptr64

  3. decltype注意点:

    #include<iostream>
#include <climits>
#include<typeinfo>
int main()
{
	int i = 42, * p = &i, & r = i;
	decltype(r + 0) b;//表达式加法结果为int类型，b为未初始化的int
	decltype(*p) c=i; //如果表达式的内容是解引用操作则为引用类型，c为int&类型	
	decltype(r) d = i;//r本身是一个引用类型，所以d为引用类型
	decltype((i)) e = i;//变量名加上括号是引用类型，所以e是引用类型
	decltype((i + i)) f;//表达式加上括号不是引用类型
	const int* const num = &i;
	decltype(num) ret = &i;//ret属于指向常量的常量指针
	int z = 100;
	//*ret = 10;
	//ret = z;
}

  4. 如果一个表达式中已经有了std::string的size()函数，就不要使用有符号整形，因为size()有可能返回一个unsigned int类型的数据。

  5. string的加号+必须保证+号的两侧至少有一个是string

    #include<iostream>
#include <climits>
#include<typeinfo>
int main()
{
	std::string s1 = "123";
	std::string s2 = "123" + s1 + "sdf";
	std::string s3 = s1 + "123" + s2;
	std::string s4 = (s1 + "sdf") + "sdf"; 
}

  6. vector初始化注意一下代码:

    #include <iostream>
#include <climits>
#include <vector>
int main()
{
	std::vector<int> svec;
	std::vector<int> svec1(svec);
	std::vector<int> svec2 = svec;
	std::vector<std::string> svec3{ "wer","sdf","Sdf" };
	//std::vector<std::string> svec4("wer", "sdf", "Sdf");
	std::vector<std::string> svec4(10, "wer");//创建10个wer
	std::vector<int> svec5(10);//创建10个值为0的int类型
	std::vector<int> svec6{ 10 };//创建一个值为10的int类型
	std::vector<int> svec7(10, 1);//创建10个值为1的int类型
	std::vector<int> svec8{ 10,1 };//创建一个为10和一个为1的int类型
	std::cout << svec6.front() << std::endl;
}

  7. 范围for语句for(statement : expression)体内不允许改变其遍历序列

  8. 迭代器中iterator可读写相关对象的元素，const_iterator只可以读取，不可以写相关元素。

    #include <iostream>
#include <climits>
#include <vector>
int main()
{
	std::vector<int> vec{ 1,4,2,4,6,23 };
	std::vector<int>::iterator it1 = vec.begin() + 2;
	*it1 = 100;
	for (auto x : vec)
	{
		std::cout << x << " ";
	}
	std::cout << std::endl;
	std::vector<int>::const_iterator it2 = vec.begin() + 2;
	//*it=10;
	std::cout << *it1 << " " << *it2 << std::endl;
}

  9. begin和end迭代器返回的具体类型由对象是否是常量决定，如果是常量，begin和end返回const_iterator,如果不是常量返回iterator，而cbegin和cend不管是否是常量容器都会返回const_iterator类型

Cpp-Primer-5th-Notes-CN-master.zip
09-23
《C++ Primer》第五版的笔记，作为该书的中文版笔记，其内容无疑是与原版教材紧密相连的。作为一本广受好评的C++学习教材，第五版在前几版的基础上进行了更新与完善。内容涵盖了C++语言的核心特性，包括变量和基本...
Cpp-primer-notes:阅读cpp入门5版时要注意的事项
03-08
这份"Cpp-primer-notes"很可能是作者在学习过程中整理的一些重点、难点以及易错点的集合，对于初学者和有一定经验的开发者来说都是宝贵的参考资料。以下将根据标题和描述中的信息，结合C++ Primer的学习内容，展开...
cpp primer笔记090-动态内存
LEVIATHANq的博客
10-06 196
每个shared_ptr都有一个关联的计数器，通常称其为引用计数，当调用了shared_ptr的构造函数时就会递增，当调用析构函数时就会递减，一旦一个shared_ptr的计数器为0的时候，它就会自动释放自己所管理的对象。如果想让STL的容器产生类似于shared_ptr指针的效果，可以进行下面的操作:(如果一个shared_ptr指向的对象的引用次数为0，则该对象会被销毁)shared_ptr和unique_ptr都支持的操作，加上shared_ptr独有的操作。
cpp primer笔记100-拷贝控制
LEVIATHANq的博客
10-06 122
移动构造函数需要notexcept修饰的原因是，如果在对vector进行push_back重新分配空间时，移动失败的话vector内的元素会发生改变，可能已经不存在，导致程序后面发生错误，拷贝失败的话，vector旧元素并不发生改变，vector原有元素还是会存在的。移动构造函数基本是针对指针进行操作的，移动是将原有的指针指向的位置传递给新的指针，并且将原有的指针置空，拷贝是将原有的指针指向的数据copy一份给新的指针，所以移后原对象基本可以说是报废不可用，所以说不建议对移后原对象进行操作。
cpp primer笔记070-算法函数
LEVIATHANq的博客
10-06 155
lambda表达式一般构成部分为一下四种，(注意:lambda表达式不能有默认参数，捕获列表只能用于局部非静态变量，对于局部静态变量和全局变量可以直接使用，如果采取值捕获的方式，则变量可以被拷贝，并且被捕获的变量的值是在lambda创建时拷贝的，而不是调用的时候。accumulate的第三个参数的类型决定了函数中使用哪个加法运算符以及返回值的类型，如果返回值是自定义类型，需要使用accumlate，则需要重载运算符，该接口的第三个参数返回的是一个需要处理的数据类型的一个变量。(这里如果a不加&号会报错)
cpp primer笔记030-参数传递
LEVIATHANq的博客
10-06 119
CPP定义了一组异常类，分别被放在4个头文件中，其中exception头文件定义类最通用的异常类exception，只报告异常的发生，不提供任何额外信息；CPP11引入begin和end函数，其使用和STL的begin和end类似，只不过需要传递一个数组首元素地址，如果有两个指针指向同一个数组的元素，或者指向该数组的尾元素的下一位置。c_str函数返回的是const char*类型的C风格字符串指针，c_str无法保证返回值一直有效，事实上，如果后续的操作改变了s的值就可能让之前返回的数组失去效用。
cpp primer笔记050-OI库
LEVIATHANq的博客
10-06 137
tie函数有两个重载的版本，一个是不带参数，返回关联的输出流的指针:如果本对象关联到一个输出流，则返回的就是指向这个流的指针，如果对象未关联到流，返回的是空指针。tie的第二个版本接受一个指向ostream的指针，将自己关联到此ostream，即x.tie(&o)将x流关联到输出流o。每个流最多可以同时关联到一个流，但是可以有多个流同时关联到一个ostream。当一个输入流被关联到一个输出流，任何试图从输入流读取数据的操作都会先刷新关联的输出流，标准库将cout和cin关联在一起，因此cin>>val;
cpp primer笔记060-顺序容器
LEVIATHANq的博客
10-06 104
对于给定的适配器，可以使用哪些容器是有限制的。如果两个容器中较小的容器是较大的容器的前缀，则较小的容器小于较大的容器，如果两个容器中的某个位置对应的前面元素相同，但是该位置元素较大的容器大。重新分配一个对象的储存空间需要分配新的内存，并将元素从旧的空间移动到新的空间中。中b指向要删除的第一个元素，e指向要删除的最后一个元素之后的位置，如果b==e，则不删除元素。容器中的max_size代表容器能够装载最大元素的值，不同元素的容器的max_size可能不一样，一般至少有1e9的数据量。队列适配器拥有的操作。
cpp primer笔记110-面向对象程序设计
LEVIATHANq的博客
10-06 118
修改类D1和D2，把覆盖的虚函数去掉，那么D1和D2作用域内就没有名字func了，使用b1调用func(int)或者func()函数，都无法在D1作用域内找到函数名，于是在外层作用域中继续寻找，也就是在base作用域中查找，能找到重载的两个版本的函数，接着进行正常的函数匹配，也不会出现编译错误。如果基类的指针通过派生类构造，如果基类的构造函数不是虚函数，则该指针的(派生类)对象会调用基类的析构函数，因此最好将基类的析构函数用virtual修饰，从而让该指针的对象调用派生类的析构函数。
cpp primer笔记040-函数与类
LEVIATHANq的博客
10-06 93
静态数据成员不属于类的任何一个对象，所以他们不是由类的构造函数初始化的。一般来说，不能在类的内部初始化静态成员，只能在类的外部定义和初始化每个静态成员。静态数据成员可以是不完全类型，即声明和定义分开，非静态数据成员不可以是不完全类型，但是非静态引用/指针成员可以是完全类型，静态数据成员可以作为类中的函数默认实参。或者如果成员属于某个类类型，则初始化必须使用成员自己的constrexpr。聚合类是所有成员都是public的，没有定义任何构造函数，没有类内初始值，没有基类和virtual函数的类。
cpp primer plus笔记06-函数
LEVIATHANq的博客
10-07 156
对于重载函数的选择，编译器倾向于优先选择非模板函数，如果没有非模板函数，则倾向于选择从类型等各方面来说相对具体的函数，如果没有一个函数比其他函数更具体，或者没有与之相匹配的函数，则会产生错误，但是向下面的情况(第二行)，编译器会倾向于选择模板函数，而不是非模板函数。函数返回值可以是引用变量，这样就不会把数据复制到一个新的临时的位置，效率会更高，但是引用变量尽量返回函数参数的的变量，引用尽量是自定义数据结构这种复杂的数据结构，而且返回值如果是引用类型尽量加const修饰。声明为一个常量引用。
Cpp-Primer:C ++ Primer解决方案第五答案
04-01
C ++ Primer解决方案第五答案 概述 该项目仅包括C ++ Primer 5th的第8章至第19章的解决方案。 环保环境 WSL Ubuntu 20.04 编译器 gcc 9.3.0 编辑 Visual studio code ...第二部分：C ++库 ...笔记 有没有发现错误？
CppPrimer阅读笔记
04-16
自己几年前整理的C++ Primer的学习笔记
CppPrimer：C ++ Primer第五次练习的解决方案
02-21
C ++ Primer解决方案第五答案 笔记 使用GCC 4.9+ ， Clang 3.4+ MSVC 14+ ， MSVC 14+。 使用-std=c++11 （推荐： -pedantic -Wall ）标志进行编译。 您发现不正确的信息了吗？ 。 内容 第一部分：基础知识 第二...
深入理解 C/C++ 内存管理：从内存布局到动态分配
qq_67169366的博客
12-10 894
我们可以重载这两个函数来实现自定义内存管理策略，例如内存池。new调用分配内存；调用构造函数初始化对象。delete调用析构函数清理资源；调用释放内存。特性new/delete语言C 函数C++ 操作符初始化不初始化可初始化大小计算手动计算自动计算（类型）返回值void*（需强转）类型指针（无需强转）失败处理返回 NULL抛出异常对象生命周期管理不调用构造/析构函数调用构造/析构函数理解 C/C++ 内存管理是写出高效、稳定程序的基础。从内存布局到动态分配，从到。
C语言实战
2201_75969037的博客
12-11 236
摘要：本文总结了C语言在实战开发中的核心应用场景，包括基础数据类型操作、内存管理、文件处理等基础内容，以及数据结构实现、算法编写、多线程编程和网络通信等进阶应用。重点展示了变量声明、动态内存分配、文件读写、链表实现、快速排序等典型代码示例，同时介绍了POSIX线程创建和TCP网络编程方法，最后提供了gdb调试和循环展开优化等实用技巧。
C++ -- 哈希表
最新发布
2301_80059080的博客
12-12 1382
本文系统介绍了哈希表的核心概念与实现方法。首先阐述了哈希的基本思想：通过哈希函数建立键值与存储位置的映射关系，实现O(1)时间复杂度的操作。然后详细讲解了哈希函数设计（包括除法散列法、乘法散列法等）和冲突处理策略，重点分析了开放定址法（线性探测、二次探测、双重散列）和链地址法两种主要冲突解决方案。文章还提供了完整的C++实现代码，包括哈希表结构设计、扩容机制、插入/查找/删除操作等关键算法，并通过示例演示了哈希表的工作过程。最后比较了不同方法的优缺点，指出链地址法在实践中的优势。
【MCAL】CCFC3008PC-EB配置之SPI
wwjh_go的博客
12-11 565
摘要：本文介绍了DSPI(反序列化串行外设接口)的配置与应用。系统包含7个DSPI模块，实际使用了DSPI1和DSPI2两个模块。重点阐述了SPI通信的基本单元结构：Job(完整通信)、Channel(数据装载)和Sequence(操作序列)的关系。详细说明了SPI的配置流程，包括通道、任务、序列、硬件和外设等设置。最后通过工程测试验证了SPI通信功能，展示了片选信号、时钟信号以及MOSI/MISO数据线的波形图。测试结果表明系统实现了预期的SPI数据传输功能。
C++ 日志实现
weixin_42252757的博客
12-11 181
【代码】C++ 日志实现。
C++ Primer笔记：基础知识点和难点总结
C++primer 4th 笔记摘要 本资源摘要信息是基于C++ Primer 4th 版本的读书笔记，总共约 60 页，涵盖了基础和难点知识点的记录。下面是笔记的主要知识点摘要： 一、头文件的使用 * `#pragma once` 行指明编译器只...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值