C++基础——1.变量和基本类型（基于c++11）

C++11类型

基本类型

  1. 字面值常量（literal）
    比如：一个形如42的值，即为常量

  2. 变量

    • 初始值
      初始化不是赋值，初始化是创建变量的时候给一个初始值；而赋值是擦除当前值，用新值代替。
    • 列表初始化
      c++11允许使用{}来初始化变量。
      比如：
      int units_sold{0}；//表示该值被初始化为0
      同理，对于vertor:
      vector<string> astr = {"abc", "is", "alphbat"};
    • 初始化方式
      itn a = 0;//使用‘=’，拷贝初始化  
int a = {0};  
int a{0};   
int a(0);//不使用‘=’，直接初始化
      • 拷贝初始化：
        使用‘=’
        编译器把等号右边的初始值拷贝到新创建的对象中。
        只能提供一个初始值
      • 直接初始化：
        不使用‘=’，比如int a(0)
        当初始值只有一个时，使用直接初始化或拷贝初始化都行。如果初始化需要多个值，则只能用直接初始化。
        比如：
        string str(3,'c');//str = "ccc";
      • 注意：
        如果是类内初始值，那么只能使用拷贝初始化或者花括号形式，
        一定不能使用圆括号【变量后面跟着原括号像以该变量类型和原括号内容生成的一个类】（在类中有
        string a = string('c')，带有迷惑性）        。
      • 初始化值为列表时，只能使用花括号进行列表初始化。
    • 默认初始化
      没有赋值的变量编译器会自动为其赋一个初值。但是，函数内定义的内置类型变量不被初始化。
    • 作用域范围
      就近定义变量原则。

  3. 复合类型

    • 引用（别名）
      • 初始化时候绑定初始值，一旦完成绑定，无法重新绑定到另一个对象。
      • 没有引用的引用
      • 只有对象才有引用
    • 指针
      • nullptr
        建议初始化所有的指针。
      • 永远记住赋值改变的是等号左边的值。
        比如：
        int *p = nullptr;      
p = &ival;//改变的是p的内容，即存放在pi内的地址值。    
*p = 0;//改变的是*p的内容，即p指向对象的值。
    • void * 指针
    • 指向指针的指针
    • 指向指针的引用
      引用不是对象，所有没有指向引用的指针。但是指针是对象，所有存在指向指针的引用。

  4. const

    • 初始化
    const int ci = i;
int j = ci;//没有改变ci值是可以的
    • 默认情况下，const对象只在文件内有效
    • 多个文件使用const对象
      extern const int bufsize；
    • const的引用 = 也称为常量引用
      const int ci=1024;
const int &r = ci;//r不能被改变
    • 引用的类型必须与其所引用对象的类型一致
      例外：
      • 初始化常量引用允许任意表达式作为初始值
        int i = 42;
const int &r1 = i;
const int &r2 = 42;
const int &r3 = 2 * r1;
    • 对const的引用可能引用一个并非const的对象
      比如：
      int i=0;  
int &r1 = i;
const int &r2 = i;
r1 = 3;//正确
r2 = 4;//错误
      r2绑定非常量是合法的。不允许通过r2修改绑定对象。可以类比const *int常量指针。
    • 指针与const
      • 指向常量的指针（pointer to const）
        const int *** 表示 int * **内容是常量
        不能改变其所指的对象的值
        要想存放常量对象的地址，只能使用指向常量的指针。
        const double pi = 3.14;  
double *ptr = &pi;			//错误，用一个非常量指针指向常量对象  
const double *cptr = &pi;	//正确，指向常量对象的地址，需要使用常量指针。
        可以有这样的情况：
        double dval = 3.3;
const double *cptr = dval;//允许，同常量引用一样，不能通过*cptr改变dval的值。
      • const指针 = 常量指针 =（const point）
        int const 表示指针是常量
        指针是对象，可以把自身定义为常量。        因为自身是常量，不允许修改，所以定义时，就要初始化。*
      • 如何区分
        从右向左读。
        int errNumb = 0;
int *const errptr = &errNumb;//errptr永远指向errNumber，即errptr不能再指向其他对象了。
*errptr = 3;//errNumb是非常量，可以通过*errptr改变。
    • 顶层const
      表示指针本身是一个常量。
      int i = 0;
int const* p1 = &i;//p1不能改变，是顶层
const int c1 = 42; //c1不能改变，是顶层
    • 底层const
      表示指针所指对象是一个常量。
      const int *p2 = 42;//p2可以改变，是顶层
    • 指针即可以是顶层也可以是顶层。
    • constexpr 和常量表达式
      • 常量表达式
        值不会改变并且在编译过程就能得到计算结果的表达式。
        const int max_files = 20;
const int limit = max_files + 1;//都是常量表达式
      • constexpr变量
        c++11新规定，允许将变量声明为constexpr类型，由编译器来识别是不是常量表达式。
        constexpr int mf = 20;
constexpr int limit = mf + 1;
constexpr int sz = get_size();
      • constexpr声明中有定义指针，那么constexpr仅对指针有效，与指针所指对象无关。
      const int *p = nullptr;		//p是一个指向整形常量的指针（所指的内容是常量）
constexpr int *q = nullptr; //q是一个指向整数的常量指针（指针是常量）
      • constexpr指针的初始化值必须是0/nullptr/固定地址。所以函数体内不能定义（对象在堆栈上，不是固定地址）。

  5. 对复杂类型的处理

    • 别名
      • typedef
        能区分
        typedef char* pstring;
const pstring cstr = 0;
const pstring *ps;
        对于const pstring cstr = 0，const是修饰谁？
        修饰char*，修饰的是指针（即是常量指针），而不是等价const char * cstr（修饰的是指针指向的内容）
        这里需要将typedef修饰的类型作为整体去看，而不是简单的替换。
        对于const pstring *ps，ps是一个指针，该指针指向char的常量指针。（二阶指针）
      • using(新规定)
        using PP = People;，用PP作为People类的别名。
    • auto（C++11引入）
      • auto让编译器通过初始值来推算变量的类型。auto的定义必须有初始值。
      • auto忽略顶层const：
        const int ci = i, &cr  = ci;
auto b = ci;//忽略ci的顶层const，这里b是一个int类型
auto c = cr;//cr是别名，auto声明为引用所引用对象的类型，这里c是int型。
auto d = &i;//&i是int *，所以d是 int *；
auto e = &ci；//&ci是对常量对象的取址（底层的const），e是指向常量对象的指针。
      • 希望是顶层const需要明确指出：
        const auto f=ci;
      • auto的引用
        auto &g = ci;//ci是一个整形常量，那么g是整形常量引用
auto &h = 42;//错误，不能把非常量引用绑定到字面值
const auto &j = 32;//正确，常量引用绑定到字面值
    • decltype（C++11引入）
      从表达式推出要定义的变量的类型，但是不想用该表达式的值初始化变量。
      decltype(f()) sum = x;//sum的类型是f()的返回类型
      • decltype处理顶层const和引用的方式 与 auto不同：
        const int ci = 0, &cj = ci;
decltype(ci) x = 0;	//x是const int
decltype(cj) y = x;	//y是const int&
decltype(cj) z;		//z是const int&，没有初始化，错误
      • decltype 与 引用
        decltype使用的表达式不是一个变量，则decltype返回表达式结果对应得类型。
        int i = 42, *p = &i, &r = i;
decltype(r+0) b;
//decltype(r) x，x是int &，但是b是 r+0的表达式，其是r（i的别名）+0的结果的类型，所以b是int类型。  
decltype (*p) c;
//decltype(p) y，y是int *类型，但是decltype(*p)是解引用操作，即为int &c；错误，需要初值。
      • decltype((val))和decltype()
        双括号永远是引用，单括号看值类型。

  6. 自定义结构

    • c++11支持类内初始值，之前版本不支持（被认为还没有实例，不能被赋值）。
      • c++11中没有被赋初始值的，会被赋默认值。
      • 类内初始值限制：放花括号，或等号右边。一定不能放圆括号。（圆括号是对象实例初始化使用，这里还没有对象实例）
posted @ 2016-02-27 01:00  sjdang  阅读(258)  评论(0)  编辑  收藏  举报