About c++（基础篇）

c++ prime 基础篇

数组赋值

int li[] {1,2,3,4,5,6};  //'='可省略

计算数组长度

sizeof(arryName)/sizeof(arry[0]);

end(arryName) - begin(arrryName)   //需要c++ 11,14支持

字符串空格拼接

cout<<"hello" "wolrd"<<endl;   使用' '的字符串可以自动拼接

字符串标准库

地址

#include <cstring>

使用字符串：
#include<string>
using namespace std;

string && char

string：
    '+',
    '=',
    '+=',
    .length(),

char:
    strcat(),
    strcpy(),strncpy() 可以限制字符数
    strlen(), 

字符串比较：
strcmp(str1,str2);

结构化赋值

structName st {"name"，"time"，3}；//'='可省略

创建结构时还可以 限制位数
struct Name {
    unsigned int SN : 4;   //4bits for SN
    bool good : 1;        
}

union

union one {
    int int_val;
    long long_val;
};
每次只可以存储一个类型的值；可匿名使用 用于减少内存

enum

enum {red,orange,yellow};

指针理解

int a = 10;
int *p = &a;  // *p = 10  赋值时 int*是一个组合类型 p是地址 *p是指向p地址的指针

int* lt = new int[10] //lt指向数组的第一个元素地址 及lt[0]
当lt++时实际是将地址指向下一元素地址及 lt[1]

使用new[] 创建数组时(动态数组)需要通过delete[]释放
int size;
cin>>size;
int *pz = new int[size];
...
delete [] pz;

对于数组：
arr[i] == *(arr + i)    //true
&arr[i] == arr+i        //true

vector array

#include<vector>
using namespace std;
vector<typeName> vt(n_elem);

#include<array>
using namespace std;
array<typeName,n_elem> arr;

基于范围的for循环 c ++11

int list[] {1,2,3,4,5,6,23,24,1254,1233};
//修改元素 使用引用类型
for(int &x:list){
    x++;
}
//不修改元素
for(int x:list){
   cout<<x<<endl;
}

备注：
int i;
for(i=0;i<5;i+=3){}
cout<<i<<endl; //6 

EOF

检测文件尾EOF
gofish <fileName 从fileName文件读取

cctype库

用来检查一个传入的字符型参数是否属于某一个的类别
 isalnum     检查字符是否为字母数字
 isalpha     检查字符是否为字母
 isblank  (c++ 11)   检查字符是否为空格空白
 iscntrl     检查字符是否为控制字符
 isdigit     检查字符是否为十进制数
 isgraph     检查字符是否有图形输出
 islower     检查字符是否为小写字母
 isprint     检查字符是否能输出
 ispunct     检查字符是否为标点
 isspace     检查字符是否为区域空白
 isupper     检查字符是否为大写字母
 isxdigit    检查字符是否为十六进制的数
 用来在两个在大小写字母之间转换
 tolower    将大写字母转换为小写字母
 toupper    将小写字母转换为大写字母

简单文件读写

ofstream outFile;
ifstream inFile;

outFile.open("fileName",ios::out); //可以添加第二个参数确定文件操作类型

ios::in     为输入(读)而打开文件
ios::out    为输出(写)而打开文件
ios::ate    初始位置：文件尾
ios::app    所有输出附加在文件末尾
ios::trunc  如果文件已存在则先删除该文件
ios::binary 二进制方式

使用<< >>读写文件
outFile.is_open() 判断文件成功打开

使用数组作为参数

当数组作为参数时，不能够通过sizeof(list)/sizeof(list[0]) 来计算数组长度。
数组作为参数时，传递的是数组首元素的内存地址，并不是实际的拷贝数组。
因此使用
    void fillArray(int arr[],size) 
或
    void fillArray(int *arr,size)
代替
    void fillArray(int arr[])

使用数组区间传递参数

int arr_sum(const int *begin,const int *end);

int main(int argc, const char * argv[]) {
    int list[] = {1,2,3,4,44,12,4,12,3};

    cout<<arr_sum(list,list+9)<<endl;
    return 0;
}

int arr_sum(const int *begin,const int *end) {
    int sum = 0;
    const int *pt;
    for(pt = begin; pt != end;pt++) {
        sum += *pt;
    }
    return sum;
}

const 指针

    int fr = 10;
    const int *pr = &fr;
    cout<<*pr<<endl;   //10
    fr = 20;
    cout<<*pr<<endl;   //20
    int frN = 30;
    pr = &frN;
    cout<<*pr<<endl;   //30

处理char[]参数

void arr_sum(const char *str);

int main(int argc, const char * argv[]) {
    char list[] = "hello world";
    arr_sum(list);
    return 0;
}

void arr_sum(const char *str) {
    while(*str) {         //结束 \0
        cout<<* str++;
    }
}

结构体参数

void say(T *t) {
    cout<<t->t1<<endl;
    cout<<t->t2<<endl;
}

void say(T t) {
    cout<<t.t1<<endl;
    cout<<t.t2<<endl;
}

函数指针

int add(int nLeft,int nRight);      //函数定义  
int (*pf)(int,int);                 //声明指针
pf = add;        //通过赋值使得函数指针指向某具体函数 
typedef int (*PF)(int,int);         //使用type简化定义
PF pf;

调用:
pf = add;//pf是函数指针  
fuc(1,add);//add自动转换为函数指针  
fuc(1,pf);  

作为形参：
//第二个形参为函数类型，会自动转换为指向此类函数的指针  
Void fuc(int nValue,int pf(int,int));  
//等价的声明，显示的将形参定义为指向函数的指针  
Void fuc(int nValue,int (*pf)(int,int));  
Void fuc(int nValue,PF);  

何时使用引用参数和指针参数

使用的主要原因：需要修改数据，传递参数引用避免浪费效率。
使用原则:
1.如果数据对象很小，如内置数据类型或小型结构，则安值传递。
2.如果数据对象是数组，只能使用指针。
3.如果数据对象是较大的结构，则使用指针或引用。
4.如果数据对象是类对象，则使用引用。

模板函数

struct stu{
  int id;
  char name[20];
};

template<typename T>
T cas(T x,T y) {
    return x + y;
}

template<> stu cas<stu>(stu x,stu y);

局限性：受类型影响，不可执行的运算。
优先级：非模板优先于显示模板优先于通用模板

decltype()

在模板函数中由于不知道T是什么类型可以通过decltype转化
int x;
decltype(x) y;  //make y the same x
参数可以是表达式
decltype(a+b) mm = a+b;

typedf decltype(x+y) xytype;
xytype xpy = x+y;
xytype arr[10];

后置返回类型

下面的代码无法使用decltype来获取类型

tmplate <class T1, class T2>
? gt(T1 x,T2 y) {
    ...
    return x+y;
}
此时可以使用后置返回类型
auto gt(T1 x,T2 y) -> double  

extern

用来定义一些在其他文件已经定义的变量
.cpp
int lit[10] = {1,2,3,4};
.h
extern int lit[10];

new定位运算符

#include <new>
using namespace std;

struct chaff {
    char dross[20];
    int slag;
};

chaff *p1,*p2;
int *p3,*p4;
//regular new
p1 = new chaff;
p3= new int[20];
//forms of placement new
p2 = new (buffer1) chaff;
p4 = new (buffer2) int[20];

区别在于 new（）使用特定区间开辟空间 

命名空间相关

using namespcace std;
using std::cout;

支持嵌套
namespace elements{
    namespcae fire{
        int flame;
    }
}

element::fire::fire;
using namespcae elements::fire;
建立别名：namespace LE = elements::fires;
未命名空间 namspace {}