C++ 语法基础

C++ 语法入门

#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!";
  return 0;
}

第1行: #include <iostream> 是一个头文件库，允许我们处理输入和输出对象，例如cout(在第5行中使用)。头文件为C++程序增加了功能。

第2行: 使用using namespace std 意味着我们可以使用标准库中的对象和变量的名称。

第3行: 空行。C++忽略了空白。

第4行: 另一个总是出现在C++程序中的东西是int main()。这叫做函数function。在它的花括号{}内的任何代码都将被执行。

第5行: cout 是与插入运算符(<<) 一起用于输出/打印文本的对象。在我们的示例中，它将输出"Hello World"。
注释： 每个C++语句以分号 ;结尾。
记住：: 编译器忽略空白。但是，多行代码使代码更具可读性。

第6行: return 0 返回0结束主功能。

第7行: 别忘了添加结束的花括号}来实际结束main函数。

省略命名空间

您可能会看到一些没有标准命名空间库运行的 C++ 程序。using namespace std行可以省略并替换为std关键字，后跟::运算符(对于某些对象)：

#include <iostream>

int main() {
  std::cout << "Hello World!";
  return 0;
}

插入新行的另一种方法是使用 endl 操纵器：

#include <iostream>
using namespace std;

int main() {
  cout << "Hello World!" << endl;
  cout << "I am learning C++";
  return 0;
}

C++ 变量

变量是存储数据值的容器。

在 C++ 中，有不同类型的变量(用不同的关键字定义)，例如：

int - 存储整数(整数)，不带小数，如123或-123
double - 存储带小数的浮点数，例如19.99或-19.99
char - 存储单个字符，如"a"或"B"。字符值用单引号括起来
string - 存储文本，例如"Hello World"。字符串值用双引号括起来
bool - 存储具有两种状态的值：true或false

#include <iostream>
using namespace std;

int main() {
  int myAge = 35;
  cout << "I am " << myAge << " years old.";
  return 0;
}

C++ 常量

当您不希望其他人(或您自己)重写现有变量值时，请使用const常量关键字(这将声明变量为"constant"，表示不可更改且为只读)：

#include <iostream>
using namespace std;

int main() {
  const int minutesPerHour = 60;
  const float PI = 3.14;
  cout << minutesPerHour << "\n";
  cout << PI;
  return 0;
}

C++ 用户输入

cout 用于输出，并使用插入运算符 (<<)
cin 用于输入，并使用提取运算符 (>>)

您已经了解到 cout用于输出(打印)值。现在我们将使用cin来获取用户输入。
cin 是一个预定义变量，它使用提取运算符(>>)从键盘读取数据。
在下面的示例中，用户可以输入一个存储在变量x中的数字。然后我们打印x的值：

#include <iostream>
using namespace std;

int main() {
  int x;
  cout << "Type a number: "; // Type a number and press enter
  cin >> x; // Get user input from the keyboard
  cout << "Your number is: " << x;
  return 0;
}

C++ 数据类型

int   4 bytes   存储整数，不含小数
float   4 bytes   存储包含一个或多个小数的小数。足够存储7位小数
double   8 bytes   存储包含一个或多个小数的小数。足够存储15位小数
boolean   1 byte   存储true或false值
char   1 byte   存储单个字符/字母/数字或ASCII值

C++ 逻辑运算符

| && | 逻辑与 | 如果两个语句都为true，则返回true | x < 5 && x < 10
| || | 逻辑或 | 如果其中一条语句为true，则返回true | x < 5 || x < 4
| ! | 逻辑非 | 反转结果，如果结果为真则返回false | !(x < 5 && x < 10)

C++ 访问字符串

#include <iostream>
#include <string>
using namespace std;

int main() {
  string myString = "Hello";
  myString[0] = 'J';
  cout << myString;
  return 0;
}

C++ 字符串命名空间

一些没有标准命名空间库运行的C++程序。using namespace std行可以省略，并替换为std关键字，后跟字符串和cout对象的::运算符：

#include <iostream>
#include <string>

int main() {
  std::string greeting = "Hello";
  std::cout << greeting;
  return 0;
}

C++ 数组遍历

#include <iostream>
#include <string>
using namespace std;

int main() {
  string cars[4] = {"Volvo", "BMW", "Ford", "Mazda"};
  for(int i = 0; i < 4; i++) {
    cout << i << ": " << cars[i] << "\n";
  }
  return 0;
}

C++ 引用

引用变量是对现有变量的引用，它是使用&运算符创建的：

#include <iostream>
#include <string>
using namespace std;

int main() {
  string food = "Pizza";
  string &meal = food;

  cout << food << "\n";
  cout << meal << "\n";
  return 0;
}

C++ 内存地址

在上一页的示例中，&运算符用于创建引用变量。但它也可以用来获得一个变量的内存地址；它是变量存储在计算机上的位置。

当变量在C++中创建时，内存地址被分配给变量。当我们给变量赋值时，它被存储在这个内存地址中。

要访问它，请使用& 运算符，结果将表示变量的存储位置：

#include <iostream>
#include <string>
using namespace std;

int main() {
  string food = "Pizza";

  cout << &food;
  return 0;
}

C++ 指针

指针是一个变量，它将内存地址存储为它的值。

指针变量指向同一类型的数据类型（如int或string），并用*运算符创建。正在使用的变量的地址已分配给指针：

使用星号（string ptr）创建一个名为ptr的指针变量，它指向一个字符串变量。请注意，指针的类型必须与正在使用的变量的类型匹配。

使用&运算符存储名为food的变量的内存地址，并将其分配给指针。

现在ptr保存food的内存地址值。

#include <iostream>
#include <string>
using namespace std;

int main() {
  string food = "Pizza";  // A string variable
  string* ptr = &food;  // A pointer variable that stores the address of food

  // Output the value of food
  cout << food << "\n";

  // Output the memory address of food
  cout << &food << "\n";

  // Output the memory address of food with the pointer
  cout << ptr << "\n";
  return 0;
}

C++ 间接引用

在上一页的示例中，我们使用指针变量获取变量的内存地址（与&操作符一起使用）。但是，您也可以通过使用*运算符（取消引用运算符）使用指针来获取变量的值：

也可以更改指针的值。但请注意，这也会更改原始变量的值：

#include <iostream>
#include <string>
using namespace std;

int main() {
  string food = "Pizza";  // Variable declaration
  string* ptr = &food;    // Pointer declaration

  // Reference: Output the memory address of food with the pointer
  cout << ptr << "\n";

  // Dereference: Output the value of food with the pointer
  cout << *ptr << "\n";
  return 0;
}

C++ 通过引用传递参数

#include <iostream>
using namespace std;

void swapNums(int &x, int &y) {
  int z = x;
  x = y;
  y = z;
}

int main() {
  int firstNum = 10;
  int secondNum = 20;

  cout << "Before swap: " << "\n";
  cout << firstNum << secondNum << "\n";

  swapNums(firstNum, secondNum);

  cout << "After swap: " << "\n";
  cout << firstNum << secondNum << "\n";

  return 0;
}

C++ 类方法

注释： 你访问方法就像访问属性一样；通过创建类的对象并使用点语法(.):

要在类定义之外定义函数，必须在类内部声明它，然后在类外部定义它。这是通过指定类的名称来实现的， followed the scope resolution :: operator, 后跟函数名称：

#include <iostream>
using namespace std;

class MyClass {         // The class
  public:               // Access specifier
    void myMethod();    // Method/function declaration
};

// Method/function definition outside the class
void MyClass::myMethod() {
  cout << "Hello World!";
}

int main() {
  MyClass myObj;     // Create an object of MyClass
  myObj.myMethod();  // Call the method
  return 0;
}

C++ 构造函数

#include <iostream>
using namespace std;

class Car {        // The class
  public:          // Access specifier
    string brand;  // Attribute
    string model;  // Attribute
    int year;      // Attribute
    Car(string x, string y, int z); // Constructor declaration
};

// Constructor definition outside the class
Car::Car(string x, string y, int z) {
  brand = x;
  model = y;
  year = z;
}

int main() {
  // Create Car objects and call the constructor with different values
  Car carObj1("BMW", "X5", 1999);
  Car carObj2("Ford", "Mustang", 1969);

  // Print values
  cout << carObj1.brand << " " << carObj1.model << " " << carObj1.year << "\n";
  cout << carObj2.brand << " " << carObj2.model << " " << carObj2.year << "\n";
  return 0;
}

C++ 继承

在 C++ 中，可以从一个类继承到另一个类的属性和方法。我们将继承概念分为两类：

派生类（子类）derived class (child) - 从另一个类继承的类
基类（父级）base class (parent) - 从中继承的类
要从类继承，请使用:符号。

在下面的示例中，Car类（child）从Vehicle类（parent）继承属性和方法：

#include <iostream>
#include <string>
using namespace std;

// Base class
class Vehicle {
  public: 
    string brand = "Ford";
    void honk() {
      cout << "Tuut, tuut! \n" ;
    }
};

// Derived class
class Car: public Vehicle {
  public: 
    string model = "Mustang";
};

int main() {
  Car myCar;
  myCar.honk();
  cout << myCar.brand + " " + myCar.model;
  return 0;
}

一个类也可以从一个已经派生的类派生。

在下面的示例中，MyGrandChild派生自类MyChild（它派生自MyClass）。

C++ 多重继承

一个类也可以从多个基类派生，使用逗号分隔列表：

#include <iostream>
using namespace std;

// Base class
class MyClass {
  public:
    void myFunction() {
      cout << "Some content in parent class.\n" ;
    }
};

// Another base class
class MyOtherClass {
  public:
    void myOtherFunction() {
      cout << "Some content in another class.\n" ;
    }
};

// Derived class
class MyChildClass: public MyClass, public MyOtherClass {
};

int main() {
  MyChildClass myObj;
  myObj.myFunction();
  myObj.myOtherFunction();
  return 0;
}

C++ 多态

#include <iostream>
#include <string>
using namespace std;

// Base class
class Animal {
  public:
    void animalSound() {
      cout << "The animal makes a sound \n" ;
    }
};

// Derived class
class Pig : public Animal {
  public:
    void animalSound() {
      cout << "The pig says: wee wee \n" ;
    }
};

// Derived class
class Dog : public Animal {
  public:
    void animalSound() {
      cout << "The dog says: bow wow \n" ;
    }
};

int main() {
  Animal myAnimal;
  Pig myPig;
  Dog myDog;

  myAnimal.animalSound();
  myPig.animalSound();
  myDog.animalSound();
  return 0;
}

C++ 文件

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main () {
  // Create a text file
  ofstream MyWriteFile("filename.txt");

  // Write to the file
  MyWriteFile << "Files can be tricky, but it is fun enough!";
 
  // Close the file
  MyWriteFile.close();

  // Create a text string, which is used to output the text file
  string myText;

  // Read from the text file
  ifstream MyReadFile("filename.txt");

  // Use a while loop together with the getline() function to read the file line by line
  while (getline (MyReadFile, myText)) {
    // Output the text from the file
    cout << myText;
  }

  // Close the file
  MyReadFile.close();
}

C++ 异常处理

C++ 异常处理
在执行 C++ 代码时，可能会发生不同的错误：程序员编写的编码错误、错误输入引起的错误或其他不可预见的事情。

当发生错误时，C++ 通常会停止并生成错误消息。这个术语的技术术语是：C++ 抛出exception异常（抛出错误）。

C++中的异常处理包括三个关键字： try, throw and catch:

try 语句允许您定义要在执行时测试错误的代码块。
throw 关键字在检测到问题时抛出异常，这使我们可以创建自定义错误。
catch 语句允许您在try块中发生错误时定义要执行的代码块。

try 和 catch 关键字成对出现：

#include <iostream>
using namespace std;

int main() {
  try {
    int age = 15;
    if (age > 18) {
      cout << "Access granted - you are old enough.";
    } else {
      throw (age);
    }
  }
  catch (int myNum) {
    cout << "Access denied - You must be at least 18 years old.\n";
    cout << "Age is: " << myNum;  
  }
  return 0;
}