C++学习笔记（一）

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

文章目录

编译C++程序的步骤
Input & Output Classification 输入输出的分类(根据源分类)
输出输出
引用⭐
- 引用的性质⭐
- 引用类型做函数的参数：引用传递
动态内存管理：分配/释放
布尔变量bool
数据类型转换
- Almost Always Auto 尽量使用auto
- Auto Type Deduction(自动类型推导):decltype
简化的C++内存模型⭐
- Stack(栈)
- Heap(堆)
- Global/Static(全局区；静态区)
- Constant(常量区)

编译C++程序的步骤

Input & Output Classification 输入输出的分类(根据源分类)

1.Standard I/O

2.File I/O

3.String I/O

4.Network I/O

输出输出

Cin >> 流提取运算符

Cout << 流插入运算符

Cin.get() 从流中读并取一个字符（等待输入）

Cin.getline() 读取字符直至行尾或指定分隔符

Cin.ignore() 读取并舍弃指定数量字符

Cin.put() 将char写到流中（无格式）

Cout.flush() 将流中缓存内容全部输出

引用⭐

相当于另一个变量的别名

int x;

int& rx = x;

int x, & rx = x;

(编程规范 &靠近类型指针*也是)

引用的性质⭐

通过引用所做的读写操作实际上是作用于原变量上。

引用必须在声明的时候初始化。

int& rx; //ERROR

引用一旦初始化，引用名字就不能再指定给其它变量

#include 
int main()
{
	int x = 0;
	int y{ 10 };
	int& rx = x;
	rx = 8;

	const char* s = "Hello";
	const char* t = "World";
	const char*& r = s;
	r = t;	//s = t;
	std::cout << r << std::endl;
	std::cout << s << std::endl;
	return 0;
}

运行结果：
World
World
r是指针s的引用，所以s指向的值改变

引用类型做函数的参数：引用传递

引用可做函数参数，但调用时只需传普通变量即可

在被调函数中改变引用变量的值，则改变的是实参的值
例1
PassByValue 值传递

#include 
void swap(int x, int y)
{
    int t = 0;
    t = x;
    x = y;
    y = t;
}
int main()
{
    int a = 1, b = 42;
    std::cout << "Before calling swap()" << a << std::endl;
    std::cout << "a=" << a << std::endl;
    std::cout << "b=" << b << std::endl;
    swap(a, b);
    std::cout << "After calling swap()" << a << std::endl;
    std::cout << "a=" << a << std::endl;
    std::cout << "b=" << b << std::endl;
    std::cin.get();
    return 0;
}

运行结果：
Before calling swap()1
a=1
b=42
After calling swap()1
a=1
b=42
a, b的值未改变交换的是形参，实参未改变

//PassByPointer 指针传递

#include 
void swap(int* x, int* y)
{
    int t = 0;
    t = *x; *x = *y; *y = t;
}
int main()
{
    int a = 1, b = 42;
    std::cout << "Before calling swap()" << a << std::endl;
    std::cout << "a=" << a << std::endl;
    std::cout << "b=" << b << std::endl;
    swap(&a, &b);
    std::cout << "After calling swap()" << a << std::endl;
    std::cout << "a=" << a << std::endl;
    std::cout << "b=" << b << std::endl;
    std::cin.get();
    return 0;
}

运行结果：

Before calling swap()1
a=1
b=42
After calling swap()42
a=42
b=1

传入形参的是指针变量，交换的是指针实际指向的值
//PassByReference 引用传递

#include 
void swap(int& x, int& y)
{
    int t = 0;
    t = x; x = y; y = t;
}
int main()
{
    int a = 1, b = 42;
    std::cout << "Before calling swap()" << std::endl;
    std::cout << "a=" << a << std::endl;
    std::cout << "b=" << b << std::endl;
    swap(a, b);
    std::cout << "After calling swap()" << std::endl;
    std::cout << "a=" << a << std::endl;
    std::cout << "b=" << b << std::endl;
    std::cin.get();
    return 0;
}

运行结果：

Before calling swap()
a=1
b=42
After calling swap()
a=42
b=1
传入形参的是引用，交换的是实际引用的值

动态内存管理：分配/释放

new <类型名>(初值)；申请一个变量空间
new<类型名>（常量表达式）申请数组
申请成功返回指定类型内存的地址
申请失败抛出异常，或返回空指针

delete <指针名>；删除一个变量/对象
delete []<指针名>；删除数组空间

char* s = new char('a');//申请一个变量空间存放'a'
delete s;//删除变量，清理出空间
int* p = new int[10];//申请一个数组
delete []p;//删除数组空间

#include 
int main()
{
	int* p = nullptr;//空指针
	int* q{ nullptr };//c++Initializer List

	p = new int(42);
	q = new int[4];
	
	std::cout << "Before: *p =" << *p << std::endl;
	*p = 24;
	std::cout << "After: *p =" << *p << std::endl;
	for (int i = 0; i < 4; i++)
	{
		*(q + i) = 10 + i;
		std::cout << *(q+i) << std::endl;
	}
	delete p;
	delete [] q;
	return 0;
}

运行结果：
Before: *p =42
After: *p =24
10
11
12
13

布尔变量bool

(函数的命名应前缀“is”)
数值0对于布尔值False 非0对于布尔值True
std::boolalpha -> false/true

数据类型转换

static_cast value
auto 关键字变量的存储策略，自动变量

int a = 10;
auto au_a = a;
cout << typeid(au_a).name() << endl//结果为int
auto a1 = 10;//auto变量定义时必须初始化
auto b1;//ERROR

#include 
using std::cout;
using std::endl;
using std::cin;
auto max(int x, int y)
{
	return x > y ? x : y;
}
int main()
{
	//auto变量必须在定义时初始化
	auto x = 3;
	auto y{ 43 };//不给初值就会报错
	//定义在同个auto序列的变量必须始终推到成同一类型
	auto x1{ 1 }, x2{ 2 };//如果后面有,x3{'a'}就会报错
	//如果初始化表达式是引用或const，则去除引用或const
	int y1{ 42 }, & y2{ y1 };
	auto y3{ y2 };
	cout << typeid(y3).name() << endl;//int
	//auto关键字带上&号，则不去除引用或const
	auto& z1{ y2 };
	cout << typeid(z1).name() << endl;//结果显示为int实际为引用
	//初始化表达式为数组时，auto关键字推导类型为指针
	int p[3]{ 1,2,3 };
	auto p1 = p;
	cout << typeid(p1).name() << endl;//指针
	//若表达式为数组且auto带上&，则推到类型为数组类型
	auto& p2{ p };
	cout << typeid(p2).name() << endl;
	cout << max(x1, x2) << endl;//int[3]
	return 0;

Almost Always Auto 尽量使用auto

//Classic C++ Style		Modern C++ Style
int	x = 42;				auto x = 42;
float x = 42;			auto x = 42.f;
unsigned long x = 42;	auto = 42ul;
std::string x = "42"	auto x = "42"s;
chrono::nanoseconds x{42];auto x = 42ns;
int f(double)			auto f(double) _> int;
						auto f(double){};
						auto f = [](double){};//匿名函数

Auto Type Deduction(自动类型推导):decltype

function1()
{
	return 0;
}
function2()
{
	return 'a';
}
decltype(function1())//int
decltype(function2())//char

简化的C++内存模型⭐ Stack(栈)

编译器自动分配释放

Heap(堆)

由程序员分配释放

Global/Static(全局区；静态区)

程序启动时就在
程序结束释放

Constant(常量区)

不可修改，只读

int MyFunc(int* pi)//pi在栈
{
	char* pc;//栈
	const char* s = "Hello"//常量区
	pc = static_cast  new char[8];//pc在堆
}

看完一遍视频粗略整理的笔记，有很多疏漏和问题，欢迎指出后续会再回头巩固和补充

C++学习笔记（一）

C/C++/C#相关栏目本月热门文章