C++语法

1、基本语法和特性

1、基本语法

• 对象 - 对象具有状态和行为。例如：一只狗的状态 - 颜色、名称、品种，行为 - 摇动、叫唤、吃。对象是类的实例。
• 类 - 类可以定义为描述对象行为/状态的模板/蓝图。
• 方法 - 从基本上说，一个方法表示一种行为。一个类可以包含多个方法。可以在方法中写入逻辑、操作数据以及执行所有的动作。
• 即时变量 - 每个对象都有其独特的即时变量。对象的状态是由这些即时变量的值创建的。

2、特性

• 封装（Encapsulation）：封装是将数据和方法组合在一起，对外部隐藏实现细节，只公开对外提供的接口。这样可以提高安全性、可靠性和灵活性。

• 继承（Inheritance）：继承是从已有类中派生出新类，新类具有已有类的属性和方法，并且可以扩展或修改这些属性和方法。这样可以提高代码的复用性和可扩展性。

• 多态（Polymorphism）：多态是指同一种操作作用于不同的对象，可以有不同的解释和实现。它可以通过接口或继承实现，可以提高代码的灵活性和可读性。

• 抽象（Abstraction）：抽象是从具体的实例中提取共同的特征，形成抽象类或接口，以便于代码的复用和扩展。抽象类和接口可以让程序员专注于高层次的设计和业务逻辑，而不必关注底层的实现细节。

2、常量

1、整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

212         // 合法的
215u        // 合法的
0xFeeL      // 合法的
078         // 非法的：8 不是八进制的数字
032UU       // 非法的：不能重复后缀

85         // 十进制
0213       // 八进制 
0x4b       // 十六进制 
30         // 整数 
30u        // 无符号整数 
30l        // 长整数 
30ul       // 无符号长整数

2、浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。

当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。

3.14159       // 合法的 
314159E-5L    // 合法的 
510E          // 非法的：不完整的指数
210f          // 非法的：没有小数或指数
.e55          // 非法的：缺少整数或分数

3、作用域解析运算符 ::

用法：

1、访问命名空间的成员

namespace Namespace {
    int variable;
    void function();
}
// 访问命名空间的变量和函数
Namespace::variable = 42;
Namespace::function();

2、访问类的静态成员或嵌套类型

class MyClass {
public:
    static int staticMember;
    typedef int NestedType;
};
// 访问类的静态成员和嵌套类型
MyClass::staticMember = 10;
MyClass::NestedType myVariable;

3、访问枚举类型的常量

enum MyEnum {
    VALUE1,
    VALUE2
};
// 访问枚举类型的常量
MyEnum value = MyEnum::VALUE1;

4、解析全局作用域

在某些情况下，可能需要访问全局作用域中的标识符，即使在当前作用域中存在同名的标识符。可以使用作用域解析运算符来解析全局作用域：

int x = 5;
void foo() {
    int x = 10;
    // 访问全局作用域中的x
    ::x = 15; //访问foo外的x
}

5、多层次的作用域嵌套

namespace outer {
    int x = 5;
    namespace inner {
        int x = 10;
        void foo() {
            // 访问最内层作用域中的x
            int x = 15;
            std::cout << x << std::endl; // 输出15
            // 访问外层作用域中的x
            std::cout << inner::x << std::endl; // 输出10
            // 访问最外层作用域中的x
            std::cout << outer::x << std::endl; // 输出5
        }
    }
}

6、名字空间namespace

为防止名字冲突，引入名字空间。通过：：运算符限定某个名字属于哪个名字空间

#include 
namespace first
{
    int a;
    void f(){}
    int g(){}
}
namespace second
{
    double a;
    double f(){}
    char g;
}
int main()
{
    first::a=2;
    second::a=6.453;
    first::a=first::g()+second::f();
    second::a=first::g()+6.453;
    printf("%d\n",first::a);
}

• using namespace X; //引入整个X名字空间，X里面的变量都可以直接用
• using X::name； //使用单个名字，后面可以直接用name这个变量
• X::name； //使用这个变量

4、C++ 中的类型限定符

5、C++存储类

存储类定义 C++ 程序中变量/函数的范围（可见性）和生命周期。这些说明符放置在它们所修饰的类型之前。下面列出 C++ 程序中可用的存储类：

1、auto 存储类

自 C++ 11 以来，auto 关键字用于两种情况：声明变量时根据初始化表达式自动推断该变量的类型、声明函数时函数返回值的占位符。

C++98标准中auto关键字用于自动变量的声明，但由于使用极少且多余，在 C++17 中已删除这一用法。

根据初始化表达式自动推断被声明的变量的类型，如

auto f=3.14;      //double
auto s("hello");  //const char*
auto z = new auto(9); // int*
auto x1 = 5, x2 = 5.0, x3='r';//错误，必须是初始化为同一类型

2、register 存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。

{
   register int  miles;
}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

3、mutable 存储类

mutable 说明符仅适用于类的对象，这将在本教程的最后进行讲解。它允许对象的成员替代常量。也就是说，mutable 成员可以通过 const 成员函数修改。

4、static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。

static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。

在 C++ 中，当 static 用在类数据成员上时，会导致仅有一个该成员的副本被类的所有对象共享。

5、extern 存储类

extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 ‘extern’ 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

6、thread_local 存储类

使用 thread_local 说明符声明的变量仅可在它在其上创建的线程上访问。 变量在创建线程时创建，并在销毁线程时销毁。 每个线程都有其自己的变量副本。

thread_local 说明符可以与 static 或 extern 合并。

可以将 thread_local 仅应用于数据声明和定义，thread_local 不能用于函数声明或定义。

以下演示了可以被声明为 thread_local 的变量：

thread_local int x;  // 命名空间下的全局变量
class X
{
    static thread_local std::string s; // 类的static成员变量
};
static thread_local std::string X::s;  // X::s 是需要定义的
 
void foo()
{
    thread_local std::vector<int> v;  // 本地变量
}

6、">>“和”<<"运算符是输入和输出运算符

C++新的输入输出流库（iostream）将输入输出看成一个流，并用输出运算符<<和输入运算符>>对数据（变量和常量进行输入输出）；
cout代表标准输出流对象，屏幕窗口。cin代表标准输入流对象，键盘。

#include 
using std::cout;    //使用std名字空间内的cout
int main()
{
    double x;
    cout<<"input a count"<<std::end1;   //endl表示换行，将设备关联的缓冲区的数据内容刷入设备。
    std::cin >>a;   //等键盘输入一个count
 
    cout << a;    //屏幕窗口输出a
    return 0;
}

在C++中，">>“和”<<"运算符是输入和输出运算符，分别用于从输入流中读取数据和向输出流中写入数据。

7、C++ 函数

函数是一组一起执行一个任务的语句。每个 C++ 程序都至少有一个函数，即主函数 main()。

8、C++ 随机数

在许多情况下，需要生成随机数。关于随机数生成器，有两个相关的函数。一个是 rand()，该函数只返回一个伪随机数。生成随机数之前必须先调用 srand() 函数。
下面是一个关于生成随机数的简单实例。实例中使用了 time() 函数来获取系统时间的秒数，通过调用 rand() 函数来生成随机数：

#include 
#include 
#include 
using namespace std;
int main ()
{
   int i,j;
   // 设置种子
   srand( (unsigned)time( NULL ) );
   /* 生成 10 个随机数 */
   for( i = 0; i < 10; i++ )
   {
      // 生成实际的随机数
      j= rand();
      cout <<"随机数： " << j << endl;
   }
   return 0;
}

上述代码执行结果：

随机数： 1748144778
随机数： 630873888
随机数： 2134540646
随机数： 219404170
随机数： 902129458
随机数： 920445370
随机数： 1319072661
随机数： 257938873
随机数： 1256201101
随机数： 580322989

9、初始化数组

大括号 { } 之间的值的数目不能大于我们在数组声明时在方括号 [ ] 中指定的元素数目。

如果您省略掉了数组的大小，数组的大小则为初始化时元素的个数。

double balance[5] = {1000.0, 2.0, 3.4, 7.0, 50.0};

10、C++ 类 & 对象

类是 C++ 的核心特性，通常被称为用户定义的类型。

类用于指定对象的形式，是一种用户自定义的数据类型，它是一种封装了数据和函数的组合。类中的数据称为成员变量，函数称为成员函数。类可以被看作是一种模板，可以用来创建具有相同属性和行为的多个对象。

类的对象的公共数据成员可以使用直接成员访问运算符 . 来访问；需要注意的是，私有的成员和受保护的成员不能使用直接成员访问运算符 (.) 来直接访问。

类成员可以被定义为 public、private 或 protected。默认情况下是定义为 private。

11、C++ 继承

1、继承

基本语法：

class derived-class: access-specifier base-class   //access-specifier可以取值public、protected 或 private 几种类型。

继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行效率的效果。

当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。

// 基类
class Animal {
    // eat() 函数
    // sleep() 函数
};
//派生类
class Dog : public Animal {
    // bark() 函数
};

2、访问控制和继承

派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。

我们可以根据访问权限总结出不同的访问类型，如下所示：

3、继承类型

当一个类派生自基类，该基类可以被继承为 public、protected 或 private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。

4、多继承

多继承即一个子类可以有多个父类，它继承了多个父类的特性。

C++ 类可以从多个类继承成员，语法如下：

class <派生类名>:<继承方式1><基类名1>,<继承方式2><基类名2>,…
{
<派生类类体>
};

其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔。

12、C++ 重载运算符和重载函数

C++ 允许在同一作用域中的某个函数和运算符指定多个定义，分别称为函数重载和运算符重载。

重载声明是指一个与之前已经在该作用域内声明过的函数或方法具有相同名称的声明，但是它们的 参数列表和定义（实现） 不相同。

当您调用一个重载函数或重载运算符时，编译器通过把您所使用的参数类型与定义中的参数类型进行比较，决定选用最合适的定义。选择最合适的重载函数或重载运算符的过程，称为重载决策。

1、C++ 中的函数重载

在同一个作用域内，可以声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数、类型或者顺序）必须不同。您不能仅通过返回类型的不同来重载函数。

#include 
using namespace std;
class printData
{
   public:
      void print(int i) {
        cout << "整数为: " << i << endl;
      }
      void print(double  f) {
        cout << "浮点数为: " << f << endl;
      }
      void print(char c[]) {
        cout << "字符串为: " << c << endl;
      }
};
 
int main(void)
{
   printData pd;
   // 输出整数
   pd.print(5);
   // 输出浮点数
   pd.print(500.263);
   // 输出字符串
   char c[] = "Hello C++";
   pd.print(c);
   return 0;
}

运行结果：

整数为: 5
浮点数为: 500.263
字符串为: Hello C++

12、C++ 多态

主要通过虚函数来实现