数据基础

#include <iostream>
#include <fstream>
#include <vector>
#include <array>
using namespace std;
extern double pi = 3.1415926;//定义，如果有初值则抵消extern的作用
auto mainBase_fun1()->int (*)[5]//尾置返回 指向数组的指针
{
    static int arr[5]{2,4,6,8,10};
    return &arr;
}
class A
{
    public:
    A(int a,int b)
    :m_i1(a),m_i2(b)
    {
        cout<<"classA:"<<m_i1<<"----"<<m_i2<<endl;
    };
    ~A(){};
    public:
    int m_i1,m_i2;
};
int main()
{
    system("chcp 65001");//处理命令行中文乱码
    //算术类型
    bool bBool = false;//8bit
    char chChar = 'o';//8bit
    wchar_t wchWchar_t = 'H';//16bit
    char16_t chChar16_t = 'a';//16bit
    char32_t chChar32_t = 'a';//32bit
    short iShort = 889;//16bit
    int iInt = 997;//32bit
    long lLong = 887655;//32bit
    long long llLong = 9223372036854775807ULL;//64bit
    float fFloat = 9.8876;//32bit
    double dDouble = 9.8876;//64bit
    long double ldLongDouble = 8683456879880.7898009982345678909876543245678988765432l;//128bit
    printf("long:%ld\n",lLong);
    printf("long long:%llu\n",llLong);
    printf("long double:%lf\n",ldLongDouble);
    printf(u8"long double所占字位数：%d\n",sizeof(long double)*8);
    printf(u8"字符串字面值\n");
    printf(u8"引用本身不是对象，所以不存在指向引用的指针，定义时必须初始化\n");
    printf(u8"常量表达式是指值不会改变且在编译过程就能得到计算结果的表达式\n");
    printf(u8"一般来说如果你认定变量是一个常量表达式，那就把它声明成constexpr类型\n");
    printf(u8"常量指针，顶层指针，指针不能改变指向的指针\n");

    cout<<"sizeof(bool):"<<sizeof(bool)<<endl;//
    cout<<"sizeof(char):"<<sizeof(char)<<endl;//
    cout<<"sizeof(wchar_t):"<<sizeof(wchar_t)<<endl;//
    cout<<"sizeof(char16_t):"<<sizeof(char16_t)<<endl;//
    cout<<"sizeof(char32_t):"<<sizeof(char32_t)<<endl;//
    cout<<"sizeof(short):"<<sizeof(short)<<endl;//
    cout<<"sizeof(int):"<<sizeof(int)<<endl;//
    cout<<"sizeof(long):"<<sizeof(long)<<endl;//
    cout<<"sizeof(long long):"<<sizeof(long long)<<endl;//
    cout<<"sizeof(float):"<<sizeof(float)<<endl;//
    cout<<"sizeof(double):"<<sizeof(double)<<endl;//
    cout<<"sizeof(long double):"<<sizeof(long double)<<endl;//

    constexpr int i = 42;
    const int *const pp = &i;//靠左的const是顶层const,靠右的是底层const
    int j = 67;
    int *p = &j;
    int * const p1 = p;
    const int * p2 = &i;
    //constexpr int *p3 = p2;
    *p1 = 789;
    printf("int * const p1:%d\n",j);
    printf(u8"decltype((variable)),如果是双层括号，则结果永远是引用\n");
    int *Parray[10];//从右向左看，10个元素的数组，每个元素都是一个整型指针
    int (*Parray1)[10];//每个元素都是一个整型数值
    printf(u8"数组支持范围for\n");
    auto ia2(&Parray[0]);//ia2是一个二级指针int**
    int arr1[10]{0,1,2,3,4,5,6,7,8,9};
    int (*p3)[10] = &arr1;
    int* p4 = arr1;
    int* p5 = &arr1[0];//p3,p4,p5值相等

    printf(u8"函数A的返回类型不能是数组类型或函数类型，但可以是指向数组或函数的指针,注意指向的数组不能是函数A的局部变量\n");
    printf(u8"函数声明也称作函数原型，如果不用，也可以只声明，不定义\n");
    int arr2[5] ;
    int (*p6)[] = mainBase_fun1();
    for(int i = 0;i<7;++i)
    {
        printf(u8"返回指向数组的指针:%d\n",*(*p6+i));
    }

    printf(u8"可变参数的函数，实参类型相同，可以用initializer_list<int> il \n");
    string strPath(__FILE__);
    int iLineNum = __LINE__;
    int iStr = 0;
    for(auto c:strPath)
    {
        if(c=='\\')
        {
            strPath[iStr] = '/';
        }
        ++iStr;
    }
    int ipos = strPath.rfind('/');
    cout<<u8"当前文件："<<strPath<<endl;
    cout<<u8"当前路径："<<strPath.substr(0,ipos)<<endl;
    cout<<u8"当前行号："<<iLineNum<<endl;
    printf(u8"和数组类似，可以返回指向函数的指针，不能返回函数 auto fun1(int a)->int (*)(int* ,int)\n");
    printf(u8"如果有关键字const紧随参数列表之后，那么就说这个成员函数是个常量成员函数， \
    \f定义时参数列表后也必须加上const，常量成员函数不能改变调用它的对象\n");
    printf(u8"通过区分成员函数是否是const的，我们可以对其进行重载\n");
    printf(u8"如果没有在构造函数的初始化列表中显式地初始化成员，则该成员将在构造函数体之前执行默认初始化\n");
    printf(u8"如果成员是const、引用，或者属于某种未提供默认构造函数的类类型，我们必须通过构造函数初始值列表为这些成员提供初值\n");
    printf(u8"成员初始化顺序是按类中成员声明的顺序来的，和构造函数初始化列表的顺序没有关系\n");

    printf(u8"如果顺序容器的元素类型是内置类型或者是具有默认构造函数的类类型，可以只\
    \f为构造函数提供一个容器大小参数，如是没有默认构造函数,除了大小参数外，还必须指定一个显式的元素初始值\n");
    array<A,5>{A(0,1),A(2,3),A(4,5),A(6,7),A(8,9)};
    vector<A> vecT;
    vecT.push_back(A(35,45));
    vecT.push_back(A(36,46));
    vecT.push_back(A(37,47));
    vecT.push_back(A(38,48));
    vecT.push_back(A(39,49));
    cout<<"vecT.at(3).m_i2:"<<vecT.at(3).m_i2<<endl;
    auto item = vecT.cbegin();
    vecT.insert(item+3,A(65,75));
    cout<<"vecT.at(3).m_i2:"<<vecT.at(3).m_i2<<endl;
    system("pause");
    return 0;
}