C++11语法学习：入门教程与实践

本文提供了C++11语法学习的入门教程，涵盖了变量声明、基本数据类型、运算符及其优先级等内容。文章还详细介绍了控制结构、函数与作用域、数组与指针以及C++11的新特性，如auto关键字和lambda表达式。此外，还包括了类与对象的定义和使用方法，帮助读者全面掌握C++11语法学习。

变量声明与初始化

在C++中，变量的声明和初始化是编程的基础。变量声明需要指定变量的类型和名称，而初始化则是给变量赋初值。下面是一些示例代码来展示如何声明和初始化变量。

// 声明一个整型变量并初始化
int age = 25;

// 声明一个浮点型变量并初始化
float height = 1.75f;

// 声明一个字符变量并初始化
char grade = 'A';

// 声明一个布尔类型变量并初始化
bool isStudent = true;

基本数据类型

C++提供了多种基本数据类型，包括整数、浮点数、字符等。下面是一些常见的基本数据类型的示例代码。

// 整数类型
int a = 10;
short b = 20;
long c = 30;

// 浮点数类型
float d = 1.234f;
double e = 2.345;

// 字符类型
char f = 'A';
wchar_t g = L'B'; // 宽字符

// 布尔类型
bool h = true;
bool i = false;

运算符及其优先级

C++支持多种运算符，包括算术运算符、关系运算符、逻辑运算符等。运算符的优先级决定了表达式中的运算顺序。下面是一些常见的运算符及其优先级的示例代码。

// 算术运算符
int a = 10;
int b = 5;

int sum = a + b; // 加法
int diff = a - b; // 减法
int product = a * b; // 乘法
int quotient = a / b; // 除法
int remainder = a % b; // 求余

// 关系运算符
bool isEqual = (a == b);
bool isNotEqual = (a != b);
bool isGreater = (a > b);
bool isLess = (a < b);
bool isGreaterEqual = (a >= b);
bool isLessEqual = (a <= b);

// 逻辑运算符
bool andResult = (isEqual && isNotEqual);
bool orResult = (isEqual || isNotEqual);
bool notResult = !isEqual;

条件语句

条件语句用于根据条件执行不同的代码块。常见的条件语句有if和switch。下面是一些示例代码来展示如何使用这些条件语句。

// if 语句
int num = 10;
if (num > 0) {
    std::cout << "num is positive" << std::endl;
} else if (num == 0) {
    std::cout << "num is zero" << std::endl;
} else {
    std::cout << "num is negative" << std::endl;
}

// switch 语句
char grade = 'A';
switch (grade) {
    case 'A':
        std::cout << "Excellent" << std::endl;
        break;
    case 'B':
        std::cout << "Good" << std::endl;
        break;
    default:
        std::cout << "Unknown" << std::endl;
}

循环语句

循环语句用于重复执行一段代码直到满足某个条件。常见的循环语句有for、while和do-while。下面是一些示例代码来展示如何使用这些循环语句。

// for 循环
for (int i = 0; i < 5; i++) {
    std::cout << "Iteration: " << i << std::endl;
}

// while 循环
int i = 0;
while (i < 5) {
    std::cout << "Iteration: " << i << std::endl;
    i++;
}

// do-while 循环
int j = 0;
do {
    std::cout << "Iteration: " << j << std::endl;
    j++;
} while (j < 5);

break与continue的使用

break语句用于提前退出循环，continue语句则是跳过循环中的某些部分。下面是一些示例代码来展示如何使用break和continue。

// 使用 break
for (int i = 0; i < 10; i++) {
    if (i == 5) {
        break;
    }
    std::cout << "Iteration: " << i << std::endl;
}

// 使用 continue
for (int k = 0; k < 10; k++) {
    if (k % 2 == 0) {
        continue;
    }
    std::cout << "Iteration: " << k << std::endl;
}

函数定义与调用

函数是可重用的代码块，用于执行特定任务。定义一个函数需要指定返回类型、函数名和参数列表。调用函数则需要提供相应的参数。下面是一些示例代码来展示如何定义和调用函数。

// 定义一个简单的函数
int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(3, 4);
    std::cout << "Result: " << result << std::endl;

    return 0;
}

局部变量与全局变量

局部变量在函数内部声明，生命周期仅限于该函数的执行期间。全局变量在整个程序的执行期间都存在。下面是一些示例代码来展示如何声明和使用局部变量和全局变量。

// 全局变量的定义
int globalVar = 10;

int main() {
    // 局部变量的定义
    int localVar = 20;

    std::cout << "Global Variable: " << globalVar << std::endl;
    std::cout << "Local Variable: " << localVar << std::endl;

    return 0;
}

作用域规则

作用域规则决定了变量的有效范围。具体来说，变量的作用域可以是全局、局部或函数参数。下面是一些示例代码来展示作用域规则的影响。

// 全局变量的作用域
int globalVar = 50;

void display() {
    int localVar = 60; // 局部变量
    std::cout << "Global Variable: " << globalVar << std::endl;
    std::cout << "Local Variable: " << localVar << std::endl;
}

int main() {
    display();

    std::cout << "Global Variable: " << globalVar << std::endl;

    // localVar 在 main 函数中不可见
    // std::cout << "Local Variable: " << localVar << std::endl;

    return 0;
}

数组的声明与初始化

数组是一系列相同类型的变量的集合。可以使用方括号来声明和初始化数组。下面是一些示例代码来展示如何声明和初始化数组。

// 声明并初始化整数数组
int numbers[5] = {1, 2, 3, 4, 5};

// 声明并初始化字符串数组
char names[3][10] = {"Alice", "Bob", "Charlie"};

// 输出数组元素
for (int i = 0; i < 5; i++) {
    std::cout << "numbers[" << i << "] = " << numbers[i] << std::endl;
}

for (int i = 0; i < 3; i++) {
    std::cout << "names[" << i << "] = " << names[i] << std::endl;
}

指针的基本概念

指针是一个变量，它存储另一个变量的地址。使用指针可以更灵活地操作内存。下面是一些示例代码来展示如何使用指针。

// 声明一个指针变量
int *p;

// 分配内存给指针并初始化
p = new int(100);

// 访问指针指向的值
std::cout << "Value: " << *p << std::endl;

// 修改指针指向的值
*p = 200;
std::cout << "Modified Value: " << *p << std::endl;

// 释放内存
delete p;

数组与指针的关系

数组本质上可以被视为指针，它们可以相互转换。下面是一些示例代码来展示数组与指针的关系。

// 声明一个数组
int arr[5] = {1, 2, 3, 4, 5};

// 将数组转换为指针
int *ptr = arr;

// 使用指针访问数组元素
for (int i = 0; i < 5; i++) {
    std::cout << "arr[" << i << "] = " << ptr[i] << std::endl;
}

auto关键字

auto关键字可以自动推断变量的类型。这在处理复杂数据类型时非常有用。下面是一些示例代码来展示如何使用auto关键字。

// 使用 auto 推断类型
auto num = 10;  // int 类型
auto pi = 3.14159f;  // float 类型
auto name = "Alice";  // const char* 类型
auto result = std::vector<int>{1, 2, 3};  // std::vector<int>

// 输出变量类型
std::cout << "num: " << num << " (type: " << typeid(num).name() << ")" << std::endl;
std::cout << "pi: " << pi << " (type: " << typeid(pi).name() << ")" << std::endl;
std::cout << "name: " << name << " (type: " << typeid(name).name() << ")" << std::endl;
std::cout << "result: " << result[0] << " (type: " << typeid(result).name() << ")" << std::endl;

lambda表达式

lambda表达式是一种匿名函数，它可以定义在代码的任何位置。lambda表达式常用于处理复杂的逻辑或简化代码。下面是一些示例代码来展示如何使用lambda表达式。

// 使用 lambda 表达式
auto add = [](int a, int b) {
    return a + b;
};

std::cout << "Result: " << add(3, 4) << std::endl;

// 带有捕获列表的 lambda 表达式
int x = 10;
auto increment = [x]() mutable {
    x += 1;
    return x;
};

std::cout << "Increment Result: " << increment() << std::endl;

range-based for循环

range-based for循环是一种简洁的循环语法，用于遍历容器中的元素。下面是一些示例代码来展示如何使用range-based for循环。

// 使用 range-based for 循环
std::vector<int> numbers = {1, 2, 3, 4, 5};

for (int num : numbers) {
    std::cout << "Number: " << num << std::endl;
}

// 使用 range-based for 循环遍历二维数组
char names[3][10] = {"Alice", "Bob", "Charlie"};

for (const char *name : names) {
    std::cout << "Name: " << name << std::endl;
}

类的定义与成员变量

类是面向对象编程的基石，用于定义对象的结构和行为。类包含成员变量（数据成员）和成员函数（方法）。下面是一些示例代码来展示如何定义一个简单的类。

// 定义一个简单的类
class Student {
public:
    // 成员变量
    std::string name;
    int age;

    // 成员函数
    void display() {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
    }
};

int main() {
    // 创建对象
    Student alice;
    alice.name = "Alice";
    alice.age = 20;

    // 调用成员函数
    alice.display();

    return 0;
}

成员函数与构造函数

成员函数定义了类的行为，而构造函数则用于初始化对象。下面是一些示例代码来展示如何定义成员函数和构造函数。

// 定义一个类并使用构造函数
class Rectangle {
public:
    int width;
    int height;

    // 构造函数
    Rectangle(int w, int h) : width(w), height(h) {}

    // 成员函数
    int area() {
        return width * height;
    }
};

int main() {
    // 创建对象并调用成员函数
    Rectangle rect(10, 20);
    std::cout << "Area: " << rect.area() << std::endl;

    return 0;
}

类的继承与多态

继承允许一个类继承另一个类的成员变量和成员函数。多态则允许使用基类的指针或引用调用派生类的成员函数。下面是一些示例代码来展示如何使用继承和多态。

// 定义基类
class Animal {
public:
    virtual void speak() {
        std::cout << "Animal speaks" << std::endl;
    }
};

// 定义派生类
class Dog : public Animal {
public:
    void speak() override {
        std::cout << "Dog barks" << std::endl;
    }
};

int main() {
    // 创建基类对象
    Animal animal;
    animal.speak();

    // 创建派生类对象并使用多态
    Dog dog;
    dog.speak();

    // 使用基类指针调用派生类方法
    Animal *ptr = &dog;
    ptr->speak();

    return 0;
}

通过以上内容，我们对C++11的基本语法、控制结构、函数与作用域、数组与指针、新特性以及类与对象有了全面的了解。希望这些示例代码能够帮助你更好地理解和掌握C++编程。更多详细信息和示例，请参考慕课网（https://www.imooc.com/）上的相关课程。