C++入门：初识类和对象

C++入门：类和对象1

本节目录

• C++入门：类和对象1
• • 1.auto关键字（C++11)
  • • 1.1类型别名思考
    • 1.2auto简介
    • • typeid运算符：获取类型信息
      • 1.3 auto的使用细则
      • 1.4auto不能推到的场景
      • 2.基于范围的for循环(C++11)
      • • 2.1范围for的语法
        • 2.2范围for的使用条件
        • 3.指针控制nullptr(C++11)
        • • 3.1C++98中的指针空值
          • 4.面向过程和面向对象初步认识
          • 5.类的引入
          • 6.类的定义
          • 7.类的访问限定符及封装
          • • 7.1访问限定符
            • 7.2封装
            • 8.类的作用域
            • 9.类的实例化
            • 10.this指针
            • • 10.1this指针的定义
              • 10.2this指针的特性
              • 11. C语言和C++实现Stack的对比
              • • 11.1 C语言的实现
                • 11.2 C++实现
                • 12 总结两者区别

                  1.auto关键字（C++11)

                  auto关键字是C++11中定义的，所以一些版本较低的编译器可能无法识别auto关键字，比如DevC++，我们来看一下这个关键字的用处。

                  1.1类型别名思考

                  我们作为后面接触的程序会越来越复杂，类型也会越来越多，这样也导致很容易就会出现错误，会出现以下问题：

                  1.类型难以拼写，容易拼写错误

                  2.含义不明确导致出错

                  我们先来看看下面的代码(有点超纲，里面的知识点没有讲到)

                  #include 
                  #include 
                  int main()
                  {
                   std::map m{ { "apple", "苹果" }, { "orange", 
                  "橙子" }, {"pear","梨"} };
                   std::map::iterator it = m.begin();
                   while (it != m.end())
                   {
                   //....
                   }
                   return 0;
                  }
                  

                  std::map::iterator 是一个类型，但是该类型太长了，特别容易写错。聪明的同学可能已经想到：可以通过typedef给类型取别名，比如：

                  #include 
                  #include 
                  typedef std::map Map;
                  int main()
                  {
                   Map m{ { "apple", "苹果" },{ "orange", "橙子" }, {"pear","梨"} };
                   Map::iterator it = m.begin();
                   while (it != m.end())
                   {
                   //....
                   }
                   return 0;
                  }
                  

                  使用typedef给类型取别名确实可以简化代码，但是typedef有会遇到新的难题：

                  typedef char* pstring;
                  int main()
                  {
                   const pstring p1;    // 编译失败
                   const pstring* p2;   // 编译成功
                   return 0;
                  }
                  

                  但是为什么p1失败了，p2成功了？

                  

                  在编程时，常常需要把表达式的值赋值给变量，这就要求在声明变量的时候清楚地知道表达式的类型。然而有时候要做到这点并非那么容易，因此C++11给auto赋予了新的含义。

                  1.2auto简介

                  在早期C/C++中auto的含义是：使用auto修饰的变量，是具有自动存储器的局部变量，但遗憾的是一直没有人去使用它，大家可思考下为什么？

                  C++11中，标准委员会赋予了auto全新的含义即：auto不再是一个存储类型指示符，而是作为一个新的类型指示符来指示编译器，auto声明的变量必须由编译器在编译时期推导而得。

                  int main()
                  {
                  	int a = 0;
                  	//int b = a;
                  	auto b = a;
                  	auto c = &a;
                  	cout  };
                  struct STU{ };
                  int main(){
                      //获取一个普通变量的类型信息
                      int n = 100;
                      const type_info &nInfo = typeid(n);
                      cout
                      int x = 10;
                      auto a = &x;
                      auto* b = &x;
                      auto& c = x;
                      cout 
                      auto a = 1, b = 2; 
                      auto c = 3, d = 4.0;  // 该行代码会编译失败，因为c和d的初始化表达式类型不同
                  }
                  }
                  
                      int a[] = {1,2,3};
                      auto b[] = {4，5，6};
                  }
                  
                  int array[] = { 1, 2, 3, 4, 5 };
                  for (int i = 0; i