C++复习笔记

// CPPTEST.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

#include<map>
#include<vector>
#include<string>
#include<list>
#include<iostream>
#include <functional>
#include <fstream>
#include <regex>

using namespace std;

class CBase{
protected://注意，可以使用C#风格的定义时初始化
    std::string name = "NoOne";
    int age = -20;
    int sex = 1;
public:
    float *pData = new float[20]{1, 2, 3, 4, 5};
public:
    virtual ~CBase(){//虚析构函数，防止内存泄漏：对基类指针调用delete时，会从子类一直析构到基类
        cout << "~cbase" << endl;
    }
};

//基类的私有成员不会被继承，这和C#完全一样
class CStudent : public CBase{
public:
    std::map<int, std::string> _projs;
    CStudent(){
        pData = new float[20]{1, 2, 3, 4, 5};
    }
public:
    void SetName(const std::string& name){
        CBase::name = name;//如果CBase.name定义为私有，这里就不可访问
        this->name = name; //等价于上一行
    }

    const string& GetName(){
        return this->name;
    }

    ~CStudent(){//若采用浅拷贝，析构函数被调用多次，pData被删除多次，程序崩溃
        //规避方式：判断pData是否为空，非空才delete[] pData
        //但在不知情的情况下使用pData仍然会出问题，因此浅拷贝导致的问题不可规避
        cout << "~cstudent" << endl;
        delete[] pData;
        pData = NULL;
    }
};

void TestSTL(){
    
    auto mp = new std::map<int, std::string>();//c++11新风格 auto
    
    mp->insert({ 10, ("h你好") });//c++11新风格，不用再使用std::pair()或std::make_pair()
    mp->insert({ 20, "el" });
    for (auto var : *mp)//c++11新风格for
    {
        std::cout << var.first << "," << var.second << "," << std::endl;
    }
}

void TestClass(){
    CBase* pbase = new CStudent();
    auto pst = (CStudent*)pbase;
    pst->SetName("xxxx");
    auto name = pst->GetName();
    delete pbase;
}

int TestAdd(int a, int b){
    return a + b;
}
void TestStdFunc(std::function<int(int,int)> fun, int a, int b){
    auto ret = fun(a, b);
}

typedef int(*TestAddPtr)(int, int);

void TestPCall(TestAddPtr func, int a, int b){
    auto ret = func(a, b);
}

struct Vertex{
    bool isgood;
    float x, y, z;
    double dx;
    bool bx;
    int ix;
    bool by;
};
void TestFile(){
    int szChar = sizeof(char);
    ofstream ofs;
    ofs.open("f:/test.txt");
    ofs << "hello " << 10 << " world " << 20 << endl;

    ofs.flush();
    ofs.close();
    
    ifstream ifs;
    ifs.open("f:/test.txt");
    string str1, str2;
    int num1, num2;

    ifs >> str1 >> num1 >> str2 >> num2;

    //错误示例：二进制读写，使用std::<<或>>进行的还是ASCII码的读写
     ofstream ofsb;
    ofsb.open("f:/testb", ios::binary);
    ofsb << "hellob" << 1022;

    ofsb.flush();
    ofsb.close();
     ifstream ifsb;

    string sx;
    int nx;
    ifsb.open("f:/testb", ios::binary);
    ifsb >> sx >> nx;
    ifsb.close();

    //正确做法
    sx = "binary";
    nx = 978;
    ofsb.open("f:/testbx", ios::binary);
    ofsb.write(sx.c_str(), sx.length()*sizeof(char)+1);
    ofsb.write((const char*)&(nx), sizeof(int));
    ofsb.flush();
    ofsb.close();

    char sxr[32];
    int nxr;
    ifsb.open("f:///testbx", ios::binary);//注意这里的"///"不管有多少个/都等同于一个
    ifsb.read(sxr, sx.length()+1);
    ifsb.read((char*)&nxr, 4);

    //数据转换的更通用方式
    Vertex vt;
    vt.bx = true;
    vt.isgood = false;
    vt.x = 12;
    vt.y = 13;
    vt.z = 14;
    vt.dx = 3.9;
    vt.by = 0;

    ofstream ofsbx;
    ofsbx.clear();
    ofsbx.open("f:/testbyx2", ios::binary);
    ofsbx.write((const char*)&(vt), sizeof(Vertex));
    ofsbx.flush();
    ofsbx.close();

    ifstream ifsbx;
    Vertex vrt;
    ifsbx.clear();
    ifsbx.open("f:/testbyx2", ios::binary);
    ifsbx.read((char*)&vrt, sizeof(Vertex));

    string s1 = "hello";
    string s2 = "wrold";
    s1 = s1 + s2;
    auto s3 = s1.substr(1, 2);
}

//实现较为高效的字符串分割，限制是分割符只能是一个字符，不能是一个串
std::list<string> TestStrSplit(string s, char sep){
    std::list<string> lst;
    for (int i = 0, j = 0; i < s.length(); ++i){
        if (s[i] == sep){
            lst.push_back(s.substr(j, i - j));
            j = i + 1;
        }
    }

    //注意临时对象作为返回值了，一般情况下这是错误的用法，栈上的临时对象出了函数域后会被释放
    //但这里STL容器内部重载了=运算符，作了值拷贝就没问题了
    return lst;
}
void TestString(){

    //g正则表达式实现字符串分割
    string s1 = "a;b;c;dddd;ef;";
    string s2 = "a123b2673cdd4444a";
    std::regex re("(d+)");
    std::smatch mtch;

    //这个做法效率挺低且浪费内存，产生了很多中间字符串
    while (std::regex_search(s2, mtch, re, std::regex_constants::match_default)){
        cout << mtch.str() << endl;
        s2 = mtch.suffix();
    }

    //这个函数效率要高多了
    auto lst = TestStrSplit(s1, ';');
    
}

//返回栈上的临时对象测试
CStudent TestTempObjRet(){
    CStudent ost; //临时对象
    return ost; //调用对象的拷贝构造函数
}//出了栈后ost被释放，析构函数调用，同时成员对象被析构CStudent.name=""，但内置类型仍保持原值

//通过测试可知，将栈上对象作为函数返回值使用一般是没有问题的，但浅COPY时两个对象中的指针指向同一份
//内存，当一个对象被删除时，另一个对象中的指针就指向非法位置了，成了野指针
void TestObjConstructorAndDestructor(){
    CStudent ostx;
    ostx = TestTempObjRet(); //调用拷贝构造函数（与上面对应）
    auto name = ostx.GetName();
    auto px = ostx.pData;
}

void TestRRef(){

}

//可以使用随机访问（数组下标）说明vector在内存中是连续存放的
//这样，vector在需要扩充容量时就需要将原来内存删除，再申请一块新内存
//但这并不一定，因为内存申请时若用realloc则有可能会在原内存后面增加（原理）
void TestVector(){
    std::vector<string> sv{ "hello", "world" };
    sv[0];
    sv[1];
    
    sv.reserve(20); //旧的内容被清除
    int n = sv.capacity(); //20
    sv.push_back("a");
    sv.push_back("b");
    sv.clear(); //旧的内容被清除
    n = sv.capacity(); //20

    sv.shrink_to_fit(); //内存释放
    n = sv.capacity(); //0

}

struct CTA{
private:
    virtual void Test(){
        cout << "cta" << endl;
    }

};

class CCTA : CTA{//类和结构体可以相互继承
public:
    int _id;
    void Test() const{
        cout << "ccta-test" << endl;
    }
};

//C++中字符串有常量和变量之分，字符串遇到则结束
//C#中只有常量字符串，字符串遇到不结束，视其为正常字符
void TestStr(){
    char* ps = "hello";//字符串常量，不可修改其内容
    ps[0] = 'd'; //运行出错

    char arr[] = "hello"; //字符串变量
    char* par = arr;
    arr[0] = 'd'; //ok
}

//C++中指针字符串与数组字符串都是自动以0结尾的
void TestMemcpy(){
    
    char dest[18];
    char src[] = "hell"; //以0结尾，长度为5，若强制声明为 char src[4] = "hell"则编译报错
    char* psrc = "hell"; //以0结尾，长度为5，但测试长度strlen(psrc)为4，因为它没算尾0
    
    for (int i = 0; i < 10; ++i){

    }
    for (int i = 0, ch; (ch = psrc[i++]) != 0;){
        //这里发现字符串尾0后有许多个0，不知道原因

    }
    auto len = strlen(psrc); //4，测试长度，并没字符串的真实长度（内存中真实串），因为它有尾0
    int len2 = strlen(src); //5，字符串实际长度（内存中存储的字符串）
    int st = sizeof(src); //5，数组大小
    memcpy(dest, psrc, strlen(psrc)+1);
}
template<typename T1, class T2> class MyVector{
    std::vector<int> _lst;

public:

    void Test2();
};

template<class T1, class T2> void MyVector<T1, T2>::Test2(){

}
int _tmain(int argc, _TCHAR* argv[])
{
    TestMemcpy();
//     auto pox = new CCTA();
//     pox->Test();
// 
//     MyVector<int, float> _v;
    //_v.Test<float>();
    //TestSTL();
    //TestClass();
    //TestStdFunc(TestAdd, 10, 20);
    //TestPCall(TestAdd, 10, 23);
    //TestFile();
    //TestString();
    //TestObjConstructorAndDestructor();
    //TestVector();



    return 0;
}