C++预编译、编译、链接

C++ Premier

预编译、编译、链接

预编译：

#include <> 和include “”

搜索路径不同：

​ <>在系统规定的目录下搜索

​ ""在自己的工程目录下搜索

编译：编译器将cpp文件转化为二进制文件obj

链接：链接器将obj文件与库(lib) 链接为可执行文件exe

输入输出

cin - 标准输入

cout - 标准输出 //先输出到缓冲区里面，结束后将缓冲区中的内容刷新到屏幕上

cerr - 输出错误

clog - 输出信息

std - 标准库的命名空间

:: - 作用域运算符

/ >> : 输入运算符

<< : 输出运算符

cin>>v1>>v2 : 顺序赋值给这两个变量

cin可以跳过空格、制表符、换行符等空白字符

while (std::cin>>value) //处于无效状态的istream对象会使条件变为假
{
    sum+=value;
}

命令行Ctrl+C是强制终止进程，Ctrl+Z是中断进程

注释

// 单行注释

/* */ 界定符对注释，不能嵌套

类（class）

抽象（类）->具体（对象）

一个类定义了一个类型，以及与其相关联的一组操作

基本内置类型

C++是一种静态数据类型语言，在编译时进行类型检查；

C++定义了：算术类型、空类型(void)

C++对算术类型只规定了最小尺寸，没有规定具体是多大。x位 = 可以表示2^x种状态

计算机以比特存储数据，每个比特非0即1。可寻址的最小内存块称为字节（byte），内存的基本单元称为字（word）

大多数机器1字节 = 8bit ， 1字 = 32或64bit

无符号类型unsigned可以节省空间

unsigned char c = -1;//假设char占8比特，c的值为255//0~255
signed char c2 = 256;//假设char占8比特，c2的值未定义//-128~127

不能将unsigned和signed一起用

进制转换：

20/十进制/ 024/八进制/ 0x14/十六进制/

变量

变量：具有类型、名称、可操作的存储空间。对c++程序员来说，变量(variable)和对象(object)一般是可以互换的。

初始化

int units_sold = 0;
int units_sold(0);
int units_sold = {0};//列表初始化
int units_sold{0};//列表初始化
//如果使用列表初始化，且初始值存在丢失信息的风险，则编译器将报错

默认初始化：如果定义变量没有定义初始值，则变量被赋予默认值；默认值是由变量类型决定的，同时定义变量的位置也会有影响；内置类型由定义的位置决定，函数体之外初始化为0。每个类各自决定其初始化对象的方式（构造函数？）

应该避免未初始化变量。

变量声明与定义

只声明不定义：用extern关键字

extern double pi = 3.14; //定义，不能放在函数体内部
int main()
{
    extern int i;//只声明不定义
    int j;//声明+定义
}

变量能且只能定义一次，但可以被声明多次。

extern不是定义，是声明在其他源文件中定义的非static全局变量

作用域

C++中大部分作用域都用花括号分离

作用域分为全局作用域和块作用域（在花括号内的），对应全局变量和局部变量

如果函数有可能用到某全局变量，则不宜再定义一个同名的局部变量；否则在局部变量的生命周期结束之前，局部变量会覆盖全局变量的值。也可以使用全局访问符::显式地访问全局变量(::variable)

复合类型：引用、指针

引用

为对象起的别名，把引用和它的初始值（对象）绑定在一起，而不是将初始值拷贝给引用。引用本身并不是对象，（没有物理空间？）所以不能定义引用的引用。引用必须初始化。

左值引用

int ival = 1024;
int& refVal = ival; //引用必须初始化
refVal = 2; //等同于ival = 2;
int& refVal2 = refVal; //等同于int& refVal2 = ival;

C++新增右值引用

指针

对地址的封装，本身就是一个对象。引用不是对象，所以不存在指向引用的指针。

取地址符（&）：获取指针所封装的地址

解引用符（*）：利用指针访问对象

int* ip1;
int* ip2;//指针定义
int ival = 42;
int* p = &ival; //p是指向ival的指针
*p = 2; //等同于ival = 2

void*指针

纯粹的地址封装，与类型无关。可以用于存放任意对象的地址。

double obj = 3.14, *pd = &obj;
void* pv = &obj;
pv = pd;

指向指针的指针

int ival = 1024;
int* pi = &ival;
int** ppi = π

指针的引用

int ival = 1024;
int* pi = &ival;
int*& r = pi; // r = &ival;

*r = 0; //等同于ival = 0；

const限定符

const把变量变成一个常量，对变量的类型加以限定，变量的值不能被改变。

const对象必须初始化。

如果想在多个文件之间共享const对象，必须在变量的定义之前添加extern关键字。

const引用

对常量的引用。不能通过一个非const引用指向一个const。

const int ival = 4;
const int& refVal = ival;

常量指针：

double pi = 3.14;
const double* ptr = π
//ptr可变，*ptr不可变

指针常量：

double pi = 3.14;
double* const pip = π
//pip不可变，*pip可变

常量表达式

值不会改变并且在编译过程就能得到计算结果的表达式。

const int max_files = 20;
const int limit = max_files + 1;

constexpr变量

C++11规定允许将变量声明为constexpr类型，以便编译器来验证变量的值是否是一个常量表达式。

constexpr int max_files = 20;
constexpr int limit = max_files + 1;

typedef、auto、decltype

typedef

类型别名：提高可读性

typedef double wages;
wages hourly, weekly;

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

using ： C++11别名声明

using SI = Sales_Item;
SI Item;

auto

C++11新特性，让编译器通过初始值推断变量的类型

decltype

选择并返回操作数的数据类型；只要数据类型，不要其值

自定义数据结构

类定义：类定义可以使用关键字class或struct，最后要加上分号

二者默认的继承访问权限不同：struct默认是public的，class默认是private的

数据成员定义了类的对象的具体内容，每个对象有自己的一份拷贝

编写头文件：

预处理变量有两个状态：已定义和未定义

#ifndef, #ifdef, #define, #endif是预处理器在编译之前执行的代码，在这里的作用是==头文件保护==

#ifndef SALES_DATA_H
#define SALES_DATA_H

#include 

struct Sales_data
{
      std::string bookNo;
      unsigned units_sold = 0;
      double revenue = 0.0;
};

#endif

命名空间的using声明

using namespace nameSpaceName;

头文件不应该包含using声明，因为会被拷贝到引用该头文件的文件中。

标准库类型string（STL）

可以当作容器，装char型。最后一位装的是’\0’。

string内存是连续的，大小是可变的，可以用下标访问。

初始化：

string s1;
string s2 = s1;
string s3 = "hiya";
string s4(10,'c');

cin.ignore(std::numeric_limits < std::streamsize > ::max(), ‘\n’);可以忽略掉之前留在输入流中的换行符

string操作

C++中，字符串字面值并不是string对象

标准库类型vector（STL）

vector操作

迭代器

使用迭代器可以访问某个元素，迭代器也能从一个元素移动到另一个元素

有迭代器的类型都拥有begin和end成员

begin：返回指向第一个元素（或字符）的迭代器

end：尾后迭代器，即尾元素的下一个位置

如果容器为空，则begin和end返回的是同一个迭代器

尾后迭代器并不实际指示某一个元素，所以不能对其进行递增或解引用

vector::iterator it;
string::iterator it2; //迭代器类型，定义在每个容器里面

vector v;
auto it = v.begin();
(*it).empty();//成员访问
it->empty();//把解引用和成员访问两个操作合在一起

任何一种可能改变vector对象容量的操作，都会使得相应的迭代器失效

数组

一维数组

声明： arrayType arrayName[num];

可以使用列表初始化，但必须指定数组类型，不允许使用auto

元素个数必须是常量表达式

字符数组的特殊性：字符串字面值的结尾处还有一个空字符’\0’

数组不允许拷贝和赋值，因为等号右边的数组名字默认为一个指向首元素的指针了，只能用for循环一个一个赋值元素

p[num]相当于指针p向后移动num个位置对应的值

多维数组

声明： arrayType arrayName [num1] [num2];

int arr[3][4] = {0};// 全部元素初始化为0
int arr[3][4] = {0,3,6,9}; // {0,3,6,9,0,0,0,0,0,0,0,0}

size_t大部分时候是unsigned int的别名

for (auto& row : ia) //取出每一行
{
    for (auto& col : row) //取出每个数组
    {
        
    }
}

for (auto row : ia) //取出的数组会被编译器转换为指针
{
    for (auto col : row) //错误， int* row没有合适的begin函数
    {
        
    }
}

表达式

一元运算符：作用于一个运算对象的运算符，如取地址符（&）和解引用符（*）

二元运算符：作用于两个运算对象的运算符，如相等和乘法

三元运算符：a?b:c

运算符重载。运算对象的个数、运算符的优先级、结合律都是无法改变的。

C++表达式要么是左值，要么是右值

左值：能取到地址的表达式

右值：取不到地址的表达式（&a）

某些表达式的求值结果是对象，但它们是右值

当一个对象被作用右值的时候，用的是对象的值（内存中的内容）

当一个对象当作左值的时候，用的是对象的身份（内存中的位置）

如果表达式的求值结果是左值，decltype作用于该表达式（不是变量）得到一个引用类型。

例如：对于int* p:

因为解引用生成左值，所有decltype(*p)的结果是int&

因为取地址符生成右值，所有decltype(&p)的结果是int **

对于没有指定求值顺序的运算符来说，如果表达式修改了同一个对象，将会引发错误并产生未定义行为。

负号的求模和取余：

(-m)/n和m/(-n)都等于-(m/n)

m%(-n)等于m%n，(-m)%n等于-m%n

赋值运算符左边必须是一个可修改的左值。初始化并非赋值。

成员访问、条件、位运算符

点运算符和成员运算符都可以访问成员

ptr->mem等价于(*ptr).mem

条件运算符： cond ? expr1 : expr2

嵌套：finalgrade == (grade > 90) ? “high pass” : (grade<60) ? “fail” : “pass”

位运算符（左结合律）：（没怎么听懂）

建议仅仅将位运算符用于处理无符号类型

sizeof运算符

sizeof：返回所占的字节数

constexpr size_t sz = sizeof(ia) / sizeof(*ia); //sizeof(ia)是数组在内存中占的总字节数，sizeof(*ia)是数组第一个元素在内存中占的总字节数

数组名在大多数情况下会被当作指向其第一个元素的指针，但在sizeof、&以及decltype这类运算符的上下文中，数组名并不会退化为指针，而是代表整个数组。

类型转换

隐式转换

算术转换

指针的转换：0或字面值nullptr能够转换成任意指针类型

指向任意非常量的指针能够转换为void*，指向任意对象的指针能够转换成const void *

显式转换

强制转换 cast-name< type > (expression)

static_cast

dynamic_cast

const_cast

reinterpret_cast

int i,j;
double slope = static_cast(j) /i; //static_cast:静态强制转换，只要不包含底层const，都可以使用
//动态强制转换更安全，而静态强制转换使用更快

double d;
void* p = &d;
double* dp = static_cast(p);

const char* pc;
char* p = const_cast(pc);
char* cpc;
const char* pc2 = const_cast(cpc);
//const_cast只能改变运算对象的底层const

int* ip;
char* pc = reinterpret_cast<>char*>(ip);//类似于C风格的强制转换，char* pc = (char*) ip;

try语句块和异常处理

throw表达式：异常检测部分使用throw表达式来表示它遇到了无法解决的问题

throw runtime_error("Data must refer to same ISBN");
//抛出一个一场，终止当前的函数，并把控制权交给异常处理的代码
//runtime_error是标准库异常类型的一种，定义在stdexcept头文件

try语句块：异常处理部分使用try语句块处理异常，可以有一个或多个catch

while (cin >> item1 >> item2)
{
    try
    {
        if (item1.isbn()!=item2.isbn())
        {
            throw runtime_error("Data must refer to same ISBN");
        }
        //如果失败，代码抛出一个runtime_error异常
    }
    catch (runtime_error err)
    {
        cout<

void reset(int* ip)
{
    *ip = 0;//改变指针ip所指对象的值
    ip = 0;//只改变了ip的局部拷贝，实参未被改变
}

int main()
{
    int i = 42;
    reset(&i);
    cout<<"i="<