c++ 2.从c到c++

名字空间

//定义，同一名字空间可以定义多次：
namespace  mfc
{ int inflag; }


//使用：
mfc::inflag=3；
//或者
using mfc::inflag;
inflag=3;

输入输出：

1.带参数的操作符（setw()，setfill()等）要包含头文件iomanip
#include<iomanip>
不带参数的操作符（hex，endl等）要包含头文件iostream
#include<iostream>


2.除了setw，其他操作符一次设置，将永久改变输入输出流状态，例如：
int a=40；
cout<<”a=”<<hex<<a<<endl;//hex用一次，永久作用
cout<<”a=”<<a<<endl;//所以这里输出也是十六进制


3.输出宽度
用setw（x）设置位宽，x比真正宽度小的时候自动突破宽度：
会右对其。
cout<<setw(6)<<a<<endl;


4.用setfill（）来设置来填充宽度的字符，如
cout<<setfill(’*’);

5.用setprecision（）改变浮点数输出位数。指的是总位数，不是小数位数。如
double a=3.1415926;
cout<<setprecision(3)<<a<<endl;
//输出3.14

 

文件读写

#include<fstream>
using namespace std;

ofstream outfile;//和cout一样用
ifstream infile;//和cin一样用,也是每次读到空格和回车就停止

infile.open("hello.txt");
outfile.open("haha.txt");//没有这个文件会自动创建，有会清空内容从头开始写
//可以合并成ifstream infile("hello.txt");

infile>>a;
outfile<<"a="<<a;

string tmp;
while(getline(infile,tmp)){//getline(输入流，字符串变量)每次读入一行，返回成功或失败
    cout<<tmp<<endl;
}

infile.close();
outfile.close();

const

int x=5;
int y=6;


//1.只要是const在*左边，是“常量指针”，本质是指针，指向了常量，所以可以换个指向，但指向的值不准动。
const int *a=&x;
//int const *a=&x;与上一句等效，

//被const修饰的指针的内容不允许变化，但是指针可以指向别处，例：
//*a=9;//Error
//a=&y;//OK

//不用指针进行修改，直接对原来变量进行修改是可以的
x=10;
cout<<*a<<endl;
//10

//2.const在*右侧，就是“指针常量”，本质是常量，常量的类型是指针类型，所以这个指针不能变指向的位置。
int *const b = &y;
*b=10;//OK
b=&x//Error


//3.指针指向和指针指向的内容都不能变
const int* const c=&x;


//4.void f(const int a)参数在函数内不能改变

强制类型转换

//1.static_cast强制类型转换
//2.const_cast取消常数性
//3.dynamic_cast继承层次中的类型转换
//4.reinterpret_const不相关的类型间转换，要谨慎使用

//1.static_cast强制类型转换
int a = 8;
double b = static_cast<double>(a);//与c中的double b=(double)a;一样
cout<<b<<endl;

//2.const_cast取消常数性
const int a = 8;
const int *ptr = &a;
int *ptr2 = const_cast<int*>(ptr);//取消常量性，指针指向的内容可以改变了
*ptr2=9;
cout<<a<<*ptr<<*ptr2<<endl;//899

cout<<"a的地址是："<<&a<<endl;
cout<<"ptr指针指向："<<ptr<<endl;
cout<<"ptr2指针指向："<<ptr2<<endl;
//地址是同一个地址，但是a是const的，因此a的值还是8，两个指针指的内容都成了9.怎么做到的不知道
//如果const int a = 8;去掉const，输出的就是999了。

枚举类型

//enum <类型名> {枚举常量表};    
enum status{single, married, unknow};
status person1=unknow;
cout<<person1<<endl;//会输出整数值，就是其对应枚举常量表的第几个，unknow对应2，输出2

结构体

与类的区别是缺省状态下结构体是public，类是private
struct Point{
    double x,y;
    void setval(double,double);
};
Point p1,p2;//c++的结构体定义时候不用加struct

string

//转化为c风格字符串:s.c_str()
string filename="hello.txt";
char s[30];//不能用char s[]=filename.c_str();因为filename被析构了
strcpy(s, filename.c_str());//一定要用strcpy对返回对指针操作
cout<<s<<endl;


//求长度
cout<<file.length();

//查找子串，找不到返回-1
auto res = s.find(substr,index);//从index向右边找
auto res = s.rfind(substr,index);//从index向左找

//擦除部分
s.erase(index, length)//不指定length就删到尾，index和length都不指定就删除整个s的内容

//插入
s.insert(index, string);

//替换s.replace(index,替换走多长，要换上的字符串）
s.replace(index, 2，“haha”);

//调换
s.swap(s2);

//索引位置字符
char c=s[2];

//取子串
string substr = s.substr(2,2);

//字符串比较
if(s1>s2){}//s1==s2之类的比较，是用字典序比较

//in 和 not in
int index=s1.find_first_of("abc");//后一个string中的字符，任意一个首先出现在s1中的位置
int index=s1.find_first_not_of("abc");//后一个string中的字符，任意一个首先不出现在s1中的位置

引用

//引用就是起了个别名
int a = 3;
int &b = a;
cout<<a<<b<<endl;//33
b=1;
cout<<a<<b<<endl;//11

//参数用引用就是传递的地址，不是只传值了
swap(a,b);//函数原型是swap(int &, int &);

//输入输出流作为参数时，必须用引用
void print_row(ofstream &out){}

//引用返回,返回的就是返回的本身，不是一份拷贝。所以要保证返回的在返回后仍存在，不能是局部变量
int& val(){
int a=3;
return a;//Error，局部变量返回后就没了
}

内联函数

//代码中写函数名，编译时使用函数体替换函数名，有点像宏替换(比宏替换多了类型检查，约束更强更安全)
//为什么函数调用有额外开销？因为调用是压目前状态状态到栈中，寻址去其他的位置继续执行，之后弹栈恢复原来状态回来执行。
inline int dbtest(int a){
    return (a%2>0)?1:2;//函数体不能过大，不能包含复杂控制语句while等
}
int main(int argc, const char * argv[]) {
    int a=4;
    cout<<dbtest(a)<<endl;
    return 0;
}

mac下c++多线程

#include <iostream>
#include <thread>
#include <unistd.h>
#include <chrono> #chrono是c++11中的时间库，提供计时，时钟等功能
using namespace std;

void func1(){cout<<"thread1"<<endl;}
void func2(){cout<<"thread2"<<endl;}

int main() {
    std::thread my_thread1(func1);
    std::thread my_thread2(func2);
    usleep(100);
//    my_thread1.detach();//开启新线程后，主线程继续。运行到return就结束了，新线程可能还没完成他的工作
//    my_thread2.detach();
    my_thread1.join();//等线程运行结束再继续运行主线程后边部分
    my_thread2.join();

    cout<<"主线程"<<endl;
    return 0;
}

new/delete

int ptr=new int[100];
delete[] ptr;//注意是delete[] ptr，不是delete ptr[]

//c++会延迟分配内存，即new完没赋值的时候是不会分配内存的
const long long n=3*1024*1024*1024L;
int *p=new int[n];//此时并没有分配上这么大的内存

for(long long i=0;i<n;i++){//赋值以后才真正分配上
    p[i]=0;
}

作用域操作符号：：

#include <iostream>
using namespace std;

int var=5;
int main() {
    int var=3;
    cout<<::var<<endl;//全局变量5
    return 0;
}

例外处理try/throw/catch

try{
    if(...){
        throw ...;
    }
}
/*按catch出现的顺序查找异常*/
/*异常类型如果是类，且有基类，则应catch(子类)应该在前，catch(基类)应该在后*/
catch(){/*异常处理*/}//圆括号内是异常类型，c++用类型来区分不同异常。
catch(){}
//没被任何catch捕捉到的画就会调用unexcepted来处理，显示一条错误信息并终止该程序。
catch(...){}//可以捕获所有类型的意外

常见错误

using namespace std;和#include<xxx.h>不能共用。

混用c和c++的输入输出很危险，在使用之前，使用ios::sync_with_stdio();消除这种隐患。

inline是在声明时用。

默认参数应该在函数声明，而不是定义时给出。
默认参数在参数列表中靠右。