C++基础 - JUZI's blog

输入输出

#include<iostream>
//#include<istream>
//#include<ostream>
std::cin>>a>>b;
std::cout<<a<<std::endl;
//::作用域运算符

//读取数量不定的输入数据
while(std::cin>>value)
    sum+=value;

类 class

成员函数（member function） - 方法（method）

类型 type

基本数据类型（base type）

算术类型（arithmetic type）：包括整型（integral type）和浮点型

空类型（void）

signed 带符号的

unsigned 无符号的

20//十进制
024//八进制
0x14//十六进制
    
'a'	//字符字面值
"Hello World" //字符串总面值

转义序列（escape sequence）

换行符 \n 横向制表符 \t 报警（响铃）符 \a

纵向制表符 \v 退格符 \b 双引号 "

反斜线 \ 问号 ? 单引号 '

回车符 \r 进纸符 \f

变量（variable）

类型说明符（type specifier)

对象（object）

初始化（initialized)

int units_sold = 0;
int units_sold = {0};
int units_sold{0};
int units_sold(0);

//{}初始化变量，叫做列表初始化（list initialization)
//但当初始值存在丢失信息的风险时，编译器将报错

默认初始化（default initialized)

定义在函数体内部的内置类型变量将不被初始化（uninitialized）

分离式编译（separate compilation）：允许将程序分割为若干个文件，每个文件单独编译

声明（declaration）

定义（definition）

extern int i;	//声明i
int i;			//声明并定义i
extern int i = 1;	//定义，抵消了extern的作用

/*在多个文件中使用同一个变量时，必须将声明和定义分离，变量的定义只能出现在一个文件中，其他用到该变量的文件必须对其声明，但不能重复定义*/

标识符（identifier）：字母，下划线，数字组成

变量名：小写

类名：大写字母开头

单词间有明显区分：student_loan或studentLoan

作用域（scope）：大多数作用域以{}分隔

全局作用域（global scope）

块作用域（block scope）

内层作用域（inner scope）

外层作用域（outer scope）

复合类型（compound type）

引用（reference）：定义引用时，程序将引用和初始值绑定（bind）在一起，即别名，引用必须初始化

指针（pointer）：存放某个对象的地址，本身也是个对象

const限定符

const对象一旦创建后其值不能再改变，必须初始化。

常量表达式（const expression）

constexpr：声明为constexpr的变量一定是一个常量，且必须用常量表达式初始化

字面值类型（literal type)

类型别名（type alias）

typedef double wages;	//wages是double的别名

别名声明（alias declaration）

using SI = Sales_item;	//SI是Sales_item的别名

auto类型说明符：让编译器分析表达式所属类型

auto i = 1 + 2;

decltype：选择并返回操作数的数据类型，不实际计算表达式的值

const int ci = 0;
decltype(ci) x = 0;	//xp类型为const int
decltype(f()) sum = x; 	//sum的类型是f的返回类型，并不实际调用函数f

自定义数据结构

struct Sale_data {/* ... */} accum, trans, *salesptr;
struct Sale_data {/* ... */};

数据成员（data member）

类内初始值（in-class initializer）

预处理器（preprocessor）

头文件

#ifndef SALES_DATA_H	//变量未定义时为真，为真时执行后续操作直到#endif（#ifdef变量已定义为真）
#define SALES_DATA_H	//将该名字设定为预处理变量
/*
	......
*/
#endif

using

using namespace::name;

using std::cin;
using std::cout;
using std::endl;

标准库类型 string

表示可变长的字符序列

#include <string>
using std::string;

string s1;	//默认，空字符串
string s2 = s1;	//stirng s2(s1);
string s3 = "hiya";	//string s3("hiya");
string s4(10,'c');	//cccccccccc

getline(is,s);	//读取一整行
s.empty();
s.size();
s[n];
//== != <= < >= >

C标准库String

#include <cstring>	//string.h的c++版本
strlen(p);
strcmp(p1,p2);		//p1==p2 return 0; p1>p2 return 正值；p1<p2 return 负值；
strcat(p1,p2);		//p2加到p1后
strcpy(p1,p2);		//p2拷贝给p1

标准库类型vector

被称为容器（container）

vector<int> ivec;		//保存int类型的对象
vector<Sales_item> Sales_vec;	//保存Sales_item的对象
vector<vector<string>> file;	//保存vector的对象

vector<string> articles = {"a", "an", "the"};
vector<string> a1{"a", "an", "the"};
vector<string> a2(a1); //a2 = a1;
vector<int> v1(10);	//10个0
vector<int> v2(10,1);	//10个1
vector<int> v3{10,1};	//10和1
/*使用了{}，但提供的值又不能执行列表初始化，所以考虑用所给值构造对象*/
vector<string> v4{10};	//10个默认初始化元素
vector<string> v5{10,"hi"};	//10个"hi"

for(int i=0;i!=100;i++)
    v1.push_back(i);	//把整数值放到尾端

for(auto i:v1)
    cout<<i<<endl;

//使用数组初始化容器
int int_arr[] = {0,1,2,3,4,5};
vector<int> ivec(begin(int_arr), end(int_arr));

迭代器（iterator）

auto b = v.begin();	//b表示的迭代器指向v的第一个元素
auto e = v.end();	//e表示的迭代器指向v尾元素的下一个位置 
//end成员返回的是尾后迭代器（off-the-end iterator）

for(auto it=s.begin(); it!=s.end() && !isspace(*it); ++it)
    *it = toupper(*it);	//改成大写

vector<int>::iterator it;	//it能读写vector<int>的元素
vector<int>::const_iterator it2;	//只能读，不能写

//解引用
*it

数组

字符数组结尾需要有一个位置存放空字符

int a[] = {0,1,2};
int b[] = a;	//错误，不允许使用一个数组初始化另一个数组
b = a;	//错误，不允许把一个数组直接赋值给另一个数组

string nums[] = {"one","two","three"};
string *p = &nums[0];	//p指向nums的第一个元素 等价于 string *p = nums;
++p;	//p指向nums[1]

int ia[2][3] = {
    {0, 1, 2},	//第一行
    {3, 4, 5}	//第二行
}

一元运算符（unary operator）

二元运算符（binary operator）

优先级（precedence)

结合律（associativity）

重载运算符（overloaded operator)

右值（rvalue）

左值（lvalue）

位运算符

~	位求反	1变0,0变1
<<	左移	右侧插入0，超出边界的位丢弃
>>	右移	无符号数左侧插入0，有符号数左侧插入符号位的副本或值为0的二进制位
&	位与	全1为1
^	位异或	有且只有一个1，为1
|	位或	有1为1

sizeof 返回一条表达式或一个类型名字所占的字节数

类型转换

隐式转换（implicit conversion）

算术转换（arithmetic conversion）

整数提升（integral promotion）

强制类型转换（cast）

形参（parameter）

实参（argument）

自动对象（automatic object）

局部静态对象（local static object）

函数原型（function prototype）

引用传递（passed by reference）

传引用调用（called by reference）

值传递（passed by value）

传值调用（called by value）

void reset(int &i)	//i是传给reset函数的对象的另一个名字
{
    i=0;	//改变了i所引用的对象
}
//使用引用避免拷贝
//如果函数无须改变引用形参的值，最好将其声明为常量引用
bool isShorter(const string &s1, const string &s2)
{
    return s1.size() < s2.size();
}

重载（overloaded）函数

默认实参（default argument）

string screen(sz ht=24,sz wid=22,char back=' ');

内联函数（inline）

constexpr函数

assert预处理宏（preprocessor marco）

//expr为真，什么也不做，expr为假，输出信息并终止程序
assert(expr);

NDEBUG预处理变量

#define NDEBUG
//定义后将关闭调试状态，assert什么也不做

函数指针

bool (*pf)(const string &, const string &);
//pf是指向函数的指针，返回值是bool
bool b1 = pf("hello","goodbye");
bool b2 = (*pf)("hello","goodbye");

数据抽象（data abstraction）

封装（encapsulation）

抽象数据类型（abstract data type）

成员函数（member function）

常量成员函数（const member function）

构造函数（constructor）：初始化对象的数据成员

默认构造函数（default constructor）：没有显式的定义构造函数时，编译器自动生成。如果存在类内初始值，用它来初始化成员，否则，默认初始化该成员

//既需要其他形式的构造函数，也需要默认的构造函数时，使用该语句
Sales_data() = default;		//默认构造函数
//如果定义了其他构造函数，最好也提供一个默认构造函数

构造函数初始值列表（constructor initialize list）

//外部定义构造函数
Sales_data::Sales_data(std::istream &is)
{
    read(is, *this);
}

编译器会替我们合成拷贝、赋值和销毁的操作，但对于某些类来说，合成的版本无法正常工作。

访问说明符（access specifiers）：加强类的封装性

public

private

使用class和struct定义类的唯一区别就是默认的访问权限，class成员的默认访问权限是private，struct成员的默认访问权限是public。

友元（friend）：允许其他类或者函数访问它的非公有成员

一般来说，最好在类定义开始或结束前的位置集中声明友元

内联函数inline

可变数据成员（mutable data member）

//前向声明（forward declaration），仅声明类而暂时不定义它
class Screen;	//不完全类型（incomplete type）

名字查找（name lookup）：

首先，在名字所在的块中寻找声明语句，只考虑在名字的使用之前出现的声明
如果没找到，继续查找外层作用域
未找到匹配的声明，报错

委托构造函数（delegating constructor)：一个委托构造函数使用它所属类的其他构造函数执行它自己的初始化过程。

转换构造函数（converting constructor）

explicit：抑制构造函数定义的隐式转换

聚合类（aggregate class）

所有的成员都是public
没有定义任何构造函数
没有类内初始值
没有基类，没有virtual函数

static：声明静态成员

//使用作用域运算符访问静态成员
r = Account::rate();

//成员函数可以直接使用静态成员
//静态数据成员不属于类的对象，一般必须在类的外部定义和初始化每个静态成员