亚洲在线久爱草,狠狠天天香蕉网,天天搞日日干久草,伊人亚洲日本欧美

為了賬號安全，請及時綁定郵箱和手機立即綁定

C++零基礎資料：新手入門必備教程

標簽：
C++
概述

C++零基础资料涵盖了新手入门所需的全部内容，包括语言简介、环境搭建、基础语法和控制结构等。文章详细介绍了变量类型、运算符、输入输出操作以及条件和循环语句。此外，还深入讲解了面向对象编程中的类与对象、封装、继承和多态等概念。通过这些内容，读者可以全面掌握C++编程的基础知识。

C++零基础资料：新手入门必备教程
C++简介与环境搭建

C++语言简介

C++是一种静态类型的、编译式的、通用的、大小写敏感的、既支持过程化编程又支持面向对象编程的编程语言。它由Bjarne Stroustrup在1979年至1983年间，基于C语言的框架下开发。C++的语法具有C语言的简洁性，并在此基础上增加了面向对象的特性，如类、继承、封装和多态等。

C++语言广泛应用于系统软件、嵌入式系统、游戏开发、图形用户界面、数据库系统、网络编程和Web浏览器等领域。C++的灵活性和强大的性能使其成为许多大型软件项目和高性能应用的首选语言。

下面是一个简单的“Hello, World!”程序示例，展示了如何使用C++输出文本：

#include <iostream>

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

开发环境搭建

在开始编写C++代码之前，你需要搭建一个合适的开发环境。以下是搭建C++开发环境的步骤：

  1. 下载并安装C++编译器：

    • Windows用户可以下载并安装Microsoft Visual Studio，它是一个集成开发环境（IDE），包含C++编译器。你也可以选择MinGW或GCC。
    • macOS用户可以使用Xcode，它包含Clang编译器，或者使用Homebrew安装GCC。
    • Linux用户可以使用包管理器安装GCC。例如，在Ubuntu上，你可以使用以下命令： 
      sudo apt-get update
sudo apt-get install g++

  2. 安装IDE（可选）：

    • 使用Visual Studio Code、Code::Blocks或IDEA等IDE可以提高开发效率。这些IDE提供了代码编辑、调试和运行等功能。

  3. 配置环境变量（如果使用命令行工具，例如GCC）：

    • 确保编译器的安装路径已经添加到环境变量中，以便你可以在命令行中直接调用编译器。
  4. 编写、编译和运行程序：
    • 使用文本编辑器编写C++源代码文件（例如，使用Visual Studio Code或Notepad++）。
    • 使用命令行或IDE编译源代码，然后运行生成的可执行文件。

下面是一个简单的示例，展示如何使用命令行工具编译和运行C++程序：

#include <iostream>

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

将上述代码保存为hello.cpp，然后在命令行中输入以下命令进行编译和运行：

g++ -o hello hello.cpp
./hello

第一个C++程序

编写第一个C++程序是学习任何新语言的开始。首先，你需要了解程序的基本结构。C++程序通常由.cpp文件组成，每个文件包含一个或多个函数，其中至少有一个main函数。

main函数是程序的入口点，程序从这里开始执行。下面是一个简单的Hello World程序：

#include <iostream>

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

该程序使用#include指令引入了iostream头文件，该文件提供了输入输出流功能，如std::cout，用于输出字符串。

在命令行中编译并运行该程序：

g++ -o hello hello.cpp
./hello

这将输出：

Hello, World!
基础语法

变量与数据类型

在C++中，变量用于存储数据。每个变量都有一个类型，指定了其存储的数据类型。C++支持多种数据类型，包括整型、浮点型、字符型等。下面详细介绍了这些数据类型及变量的声明和初始化方法。

基本数据类型

  • 整型：

    • int：通常用于表示整数，如int num = 10;。
    • short：短整型，如short num = 10;。
    • long：长整型，如long num = 1000000;。
    • long long：更长的整型，如long long num = 100000000000;。

  • 浮点型：

    • float：单精度浮点数，如float num = 3.14;。
    • double：双精度浮点数，如double num = 3.14159;。
    • long double：扩展精度浮点数，如long double num = 3.141592653589793238;。

  • 字符型：

    • char：用于存储单个字符，如char c = 'A';。
    • wchar_t：用于存储宽字符，如wchar_t c = L'A';。
  • 布尔型：
    • bool：用于存储布尔值，如bool flag = true;。

变量声明与初始化

变量声明是指定义变量的名字和类型，而初始化是在声明时给变量赋初值。下面是一些示例：

int num = 10;                // 整型变量，值为10
float pi = 3.14;             // 浮点型变量，值为3.14
char grade = 'A';            // 字符型变量，值为'A'
bool isTrue = true;          // 布尔型变量，值为true
short number = 100;          // 短整型变量，值为100
long long bigNumber = 100000000000; // 长整型变量，值为100000000000
double precisePi = 3.14159;  // 双精度浮点型变量，值为3.14159

变量可以在声明时进行初始化，也可以在声明后进行赋值：

int number;                  // 声明一个整型变量
number = 10;                 // 对变量赋值

变量作用域

变量的作用域指定了变量定义的位置，从而决定了变量的可见范围。在C++中，变量的作用域可以分为局部作用域和全局作用域：

  • 局部作用域：在函数内部或代码块中的变量，只在该函数或代码块内部可见。
  • 全局作用域：在函数外部声明的变量，整个程序范围内可见。

下面是一个局部变量和全局变量的示例：

#include <iostream>

int globalVar = 5;           // 全局变量

int main() {
    int localVar = 10;       // 局部变量
    std::cout << "Local variable: " << localVar << std::endl;
    std::cout << "Global variable: " << globalVar << std::endl;
    return 0;
}

基本运算符

C++提供了多种运算符，用于对变量进行操作。这些运算符包括算术运算符（如加法、减法等）、关系运算符（如比较运算符）、逻辑运算符（如逻辑与、逻辑或等）等。

算术运算符

  • +：加法，如int result = 5 + 3;。
  • -：减法，如int result = 10 - 5;。
  • *：乘法，如int result = 5 * 3;。
  • /：除法，如int result = 10 / 5;。
  • %：取模运算符，返回除法的余数，如int result = 10 % 3;。

关系运算符

  • ==：等于，如if (num == 10) {}。
  • !=：不等于，如if (num != 10) {}。
  • >：大于，如if (num > 10) {}。
  • <：小于，如if (num < 10) {}。
  • >=：大于等于，如if (num >= 10) {}。
  • <=：小于等于，如if (num <= 10) {}。

逻辑运算符

  • &&：逻辑与，如if (num > 10 && num < 20) {}。
  • ||：逻辑或，如if (num > 10 || num < 20) {}。
  • !：逻辑非，如if (!isTrue) {}。

示例

下面是一些使用算术运算符、关系运算符和逻辑运算符的示例：

#include <iostream>

int main() {
    int a = 5, b = 10;
    int result;

    result = a + b;       // 加法
    std::cout << "Addition: " << result << std::endl;

    result = a - b;       // 减法
    std::cout << "Subtraction: " << result << std::endl;

    result = a * b;       // 乘法
    std::cout << "Multiplication: " << result << std::endl;

    result = b / a;       // 除法
    std::cout << "Division: " << result << std::endl;

    result = b % a;       // 取模
    std::cout << "Modulo: " << result << std::endl;

    if (a > b) {
        std::cout << "a is greater than b" << std::endl;
    } else if (a < b) {
        std::cout << "a is less than b" << std::endl;
    }

    if (a > 5 && b < 20) {
        std::cout << "Both conditions are true" << std::endl;
    }

    if (!(a == b)) {
        std::cout << "a is not equal to b" << std::endl;
    }

    return 0;
}

输入输出操作

C++提供了多种方式来处理输入和输出操作。iostream库中的cin和cout是常用的输入输出流对象。

输出操作

cout用于输出数据到标准输出（通常是屏幕）。输出操作可以使用<<运算符。

#include <iostream>

int main() {
    int num = 10;
    std::cout << "The number is: " << num << std::endl;
    return 0;
}

输入操作

cin用于从标准输入（通常是键盘）读取数据。输入操作可以使用>>运算符。

#include <iostream>

int main() {
    int num;
    std::cout << "Enter a number: ";
    std::cin >> num;
    std::cout << "You entered: " << num << std::endl;
    return 0;
}
控制结构

条件语句

C++提供了多种控制结构来实现程序的条件判断。其中最常见的就是if语句和switch语句。

if语句

if语句用于执行条件判断，根据条件的真假来执行不同的代码块。

#include <iostream>

int main() {
    int num = 10;
    if (num > 5) {
        std::cout << "Number is greater than 5" << std::endl;
    }
    return 0;
}

if语句可以扩展为if...else和if...else if...else结构。

#include <iostream>

int main() {
    int num = 10;
    if (num > 15) {
        std::cout << "Number is greater than 15" << std::endl;
    } else if (num == 10) {
        std::cout << "Number is equal to 10" << std::endl;
    } else {
        std::cout << "Number is less than 10" << std::endl;
    }
    return 0;
}

switch语句

switch语句用于根据变量的值选择执行不同的代码块。switch语句必须与case标签结合使用。

#include <iostream>

int main() {
    int num = 2;
    switch (num) {
        case 1:
            std::cout << "Number is 1" << std::endl;
            break;
        case 2:
            std::cout << "Number is 2" << std::endl;
            break;
        default:
            std::cout << "Number is neither 1 nor 2" << std::endl;
            break;
    }
    return 0;
}

嵌套语句

嵌套语句是指在一个控制结构内部嵌套另一个控制结构。例如，可以在if语句内部嵌套一个for循环，或者在switch语句内部嵌套一个if语句。

#include <iostream>

int main() {
    int num = 10;
    if (num > 5) {
        std::cout << "Number is greater than 5" << std::endl;
        for (int i = 0; i < 3; i++) {
            std::cout << "Iteration: " << i << std::endl;
        }
    }
    return 0;
}

循环语句

循环语句用于重复执行一段代码直到满足某个条件。C++提供了for循环、while循环和do...while循环三种循环结构。

for循环

for循环用于在已知循环次数的情况下进行循环。

#include <iostream>

int main() {
    for (int i = 0; i < 5; i++) {
        std::cout << "Iteration: " << i << std::endl;
    }
    return 0;
}

while循环

while循环在满足条件时执行循环体。

#include <iostream>

int main() {
    int i = 0;
    while (i < 5) {
        std::cout << "Iteration: " << i << std::endl;
        i++;
    }
    return 0;
}

do...while循环

do...while循环至少执行一次循环体，然后在每次执行后检查条件。

#include <iostream>

int main() {
    int i = 0;
    do {
        std::cout << "Iteration: " << i << std::endl;
        i++;
    } while (i < 5);
    return 0;
}
函数与库

函数定义与调用

函数是一段具有名称的代码块，可以接受输入参数，并可返回一个结果。函数定义包括函数名、参数列表、返回类型和函数体。调用函数则是使用函数名和参数来执行该函数。

函数定义

函数定义的格式如下：

返回类型 函数名(参数列表) {
    函数体
    return 返回值;
}

示例：

#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    int result = add(5, 3);
    std::cout << "The sum is: " << result << std::endl;
    return 0;
}

函数调用

函数调用是通过函数名和参数来执行函数。调用示例如下：

int result = add(5, 3);
std::cout << "The sum is: " << result << std::endl;

函数参数与返回值

函数可以接受多个参数，并且可以返回一个值。参数是传递给函数的输入数据，而返回值是函数执行后的输出结果。

参数

参数可以是基本数据类型或复杂数据类型（如数组、指针等）。参数可以是值传递或引用传递。

示例：

#include <iostream>

int add(int a, int b) {
    return a + b;
}

int main() {
    int sum = add(5, 3);
    std::cout << "The sum is: " << sum << std::endl;
    return 0;
}

返回值

函数可以返回一个值或不返回任何值。不返回值的函数的返回类型是void。

示例：

#include <iostream>

void printHello() {
    std::cout << "Hello, World!" << std::endl;
}

int main() {
    printHello();
    return 0;
}

常用标准库介绍

C++提供了丰富的标准库，包含了各种实用的数据结构和算法。下面介绍一些常用的库。

iostream库

iostream库提供了输入输出流类，用于输入输出操作。

#include <iostream>

int main() {
    std::cout << "Hello, World!" << std::endl;
    int num;
    std::cout << "Enter a number: ";
    std::cin >> num;
    std::cout << "You entered: " << num << std::endl;
    return 0;
}

string库

string库提供了字符串处理功能。

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    std::cout << "The string is: " << str << std::endl;
    return 0;
}

vector库

vector库提供了动态数组功能。

#include <iostream>
#include <vector>

int main() {
    std::vector<int> vec = {1, 2, 3, 4};
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

algorithm库

algorithm库提供了各种算法函数，如排序、查找等。

#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec = {4, 2, 3, 1};
    std::sort(vec.begin(), vec.end());
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}
数据结构基础

数组

数组是一种数据结构，用于存储相同类型的一组元素。数组中的每个元素通过索引来访问，索引从0开始。

一维数组

一维数组是最简单的数组形式，只有一个维度。

示例：

#include <iostream>

int main() {
    int arr[5] = {1, 2, 3, 4, 5};
    for (int i = 0; i < 5; i++) {
        std::cout << "Element " << i << ": " << arr[i] << std::endl;
    }
    return 0;
}

多维数组

多维数组有多个维度，每个维度可以有不同的长度。

示例：

#include <iostream>

int main() {
    int arr[2][3] = {
        {1, 2, 3},
        {4, 5, 6}
    };
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 3; j++) {
            std::cout << "Element [" << i << "][" << j << "]: " << arr[i][j] << std::endl;
        }
    }
    return 0;
}

复杂应用场景

下面是一个复杂应用场景的示例，展示了如何对数组进行排序：

#include <iostream>
#include <algorithm>
#include <vector>

int main() {
    std::vector<int> vec = {4, 2, 3, 1};
    std::sort(vec.begin(), vec.end());
    for (int i : vec) {
        std::cout << i << " ";
    }
    std::cout << std::endl;
    return 0;
}

字符串

字符串是一种特殊的数组，用于存储字符序列。C++提供了string类来操作字符串。

字符串操作

string类提供了各种方法来操作字符串，如拼接、查找、替换等。

示例：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    std::cout << "The string is: " << str << std::endl;
    str += " Nice to meet you!";
    std::cout << "The string is: " << str << std::endl;
    std::string substring = str.substr(7, 5);
    std::cout << "Substring is: " << substring << std::endl;
    str.replace(7, 5, "C++");
    std::cout << "The string is: " << str << std::endl;
    return 0;
}

复杂应用场景

下面是一个复杂应用场景的示例，展示了如何对字符串进行复杂的拼接和替换操作：

#include <iostream>
#include <string>

int main() {
    std::string str = "Hello, World!";
    str += " Nice to meet you!";
    std::cout << "The string is: " << str << std::endl;
    std::string temp = str.substr(7, 5);
    str.replace(7, 5, "C++");
    std::cout << "The string is: " << str << std::endl;
    std::cout << "Substring is: " << temp << std::endl;
    return 0;
}

结构体

结构体是一种用户自定义的数据类型，用于组合多个不同类型的变量。结构体中的每个成员都有一个类型和名称。

结构体定义与使用

结构体定义的格式如下：

struct 结构体名 {
    数据类型 成员1;
    数据类型 成员2;
    ...
};

示例：

#include <iostream>

struct Person {
    std::string name;
    int age;
};

int main() {
    Person p;
    p.name = "Alice";
    p.age = 25;
    std::cout << "Name: " << p.name << ", Age: " << p.age << std::endl;
    return 0;
}

复杂应用场景

下面是一个复杂应用场景的示例，展示了如何在结构体中嵌套另一个结构体，以及如何使用结构体：

#include <iostream>

struct Address {
    std::string street;
    std::string city;
    std::string country;
};

struct Person {
    std::string name;
    int age;
    Address address;
};

int main() {
    Person p;
    p.name = "Alice";
    p.age = 25;
    p.address.street = "123 Main St";
    p.address.city = "Springfield";
    p.address.country = "USA";
    std::cout << "Name: " << p.name << ", Age: " << p.age << std::endl;
    std::cout << "Address: " << p.address.street << ", " << p.address.city << ", " << p.address.country << std::endl;
    return 0;
}
面向对象编程

类与对象

面向对象编程（OOP）是一种编程范式，强调程序由对象组成，而对象是由类定义的实例。类定义了对象的数据属性和方法（函数），对象是类的实例。

类定义

类定义的格式如下：

class 类名 {
    public:
        数据类型 成员变量;
        void 成员函数() {
            // 函数体
        }
};

示例：

#include <iostream>

class Person {
public:
    std::string name;
    int age;

    void setName(std::string n) {
        name = n;
    }

    void setAge(int a) {
        age = a;
    }

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p;
    p.setName("Alice");
    p.setAge(25);
    p.printInfo();
    return 0;
}

对象

对象是类的实例，通过类的构造函数创建对象。

示例：

#include <iostream>

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) : name(n), age(a) {}

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p("Alice", 25);
    p.printInfo();
    return 0;
}

封装

封装是指将数据和处理这些数据的方法绑定在一起，形成一个独立的单元，即对象。通过封装，可以隐藏对象的内部实现细节，只暴露必要的接口给外界使用。

封装示例

通过封装，可以隐藏对象的内部变量，只提供公共接口来访问和修改这些变量。

示例：

#include <iostream>

class Person {
private:
    std::string name;
    int age;

public:
    Person(std::string n, int a) : name(n), age(a) {}

    void setName(std::string n) {
        name = n;
    }

    void setAge(int a) {
        age = a;
    }

    std::string getName() {
        return name;
    }

    int getAge() {
        return age;
    }

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p("Alice", 25);
    p.printInfo();
    p.setAge(26);
    p.printInfo();
    std::cout << "Name: " << p.getName() << ", Age: " << p.getAge() << std::endl;
    return 0;
}

继承与多态

继承和多态是面向对象编程的关键特性。继承允许一个类（子类）继承另一个类（父类）的属性和方法，从而实现代码的重用。多态允许基类的指针或引用指向派生类的对象，从而实现动态绑定。

继承示例

子类可以继承父类的属性和方法，并可以重写父类的方法。

示例：

#include <iostream>

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) : name(n), age(a) {}

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

class Student : public Person {
public:
    std::string major;

    Student(std::string n, int a, std::string m) : Person(n, a), major(m) {}

    void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << ", Major: " << major << std::endl;
    }
};

int main() {
    Person p("Alice", 25);
    p.printInfo();

    Student s("Bob", 20, "Computer Science");
    s.printInfo();
    return 0;
}

多态示例

通过基类的指针或引用，可以指向派生类的对象，并通过基类的方法调用派生类的方法。

示例：

#include <iostream>

class Person {
public:
    std::string name;
    int age;

    Person(std::string n, int a) : name(n), age(a) {}

    virtual void printInfo() {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

class Student : public Person {
public:
    std::string major;

    Student(std::string n, int a, std::string m) : Person(n, a), major(m) {}

    void printInfo() override {
        std::cout << "Name: " << name << ", Age: " << age << ", Major: " << major << std::endl;
    }
};

int main() {
    Person p("Alice", 25);
    Person* ptr = &p;
    ptr->printInfo();

    Student s("Bob", 20, "Computer Science");
    ptr = &s;
    ptr->printInfo();
    return 0;
}
总结

通过以上章节的学习，你应该已经掌握了C++编程的基本语法和面向对象编程的概念。从变量和数据类型、基本运算符和控制结构，到函数、标准库和数据结构，再到面向对象编程的类、对象、封装、继承和多态，每个部分都提供了详细的概念介绍和代码示例。

继续深入学习和实践，可以帮助你更好地掌握C++编程技能。推荐的编程学习网站是慕课网（http://www.xianlaiwan.cn/），上面有许多优质的C++教程和实践项目，可以帮助你进一步提升编程水平。

點擊查看更多內容
為 TA 點贊

若覺得本文不錯，就分享一下吧！

評論

作者其他優質文章

正在加載中
  • 推薦
  • 評論
  • 收藏
  • 共同學習，寫下你的評論
感謝您的支持，我會繼續努力的～
掃碼打賞，你說多少就多少
贊賞金額會直接到老師賬戶
支付方式
打開微信掃一掃，即可進行掃碼打賞哦
今天注冊有機會得

100積分直接送

付費專欄免費學

大額優惠券免費領

立即參與 放棄機會
微信客服

購課補貼
聯系客服咨詢優惠詳情

 幫助反饋 APP下載

慕課網APP
您的移動學習伙伴

 公眾號

掃描二維碼
關注慕課網微信公眾號

舉報

0/150
提交
取消