一文总结C++运算符的使用方法

1. 算术运算符

算术运算符用于执行基本数学运算，例如加减乘除和取模等操作。下表列出了C++中支持的算术运算符：

其中，a和b代表要进行计算的两个变量或值。

（1）加法运算符

加法运算符（+）用于将两个值相加。如果两个操作数都是数字，则它们将被相加。如果其中一个操作数是字符串，则它们将被连接起来。

e.g.

int a = 5;
int b = 3;
int c = a + b; // c的值为8

std::string str1 = "Hello, ";
std::string str2 = "world!";
std::string str3 = str1 + str2; // str3的值为"Hello, world!"

（2）减法运算符

减法运算符（-）用于将第一个操作数减去第二个操作数。

e.g.

int a = 5;
int b = 3;
int c = a - b; // c的值为2

（3）乘法运算符

乘法运算符（*）用于将两个数相乘。

e.g.

int a = 5;
int b = 3;
int c = a * b; // c的值为15

注意，C++中整数除法返回整数结果，即舍去小数部分。

（5）取模运算符

取模运算符（%）返回除法的余数。

e.g.

int a = 7;
int b = 3;
int c = a % b; // c的值为1

2. 关系运算符

关系运算符用于比较两个值并返回布尔值（true或false）。下表列出了C++中支持的关系运算符：

其中，a和b代表要进行比较的两个变量或值。

（1）相等和不相等运算符

相等运算符（==）用于比较两个值是否相等。如果它们相等，则返回true，否则返回false。

e.g.

int a = 5;
int b = 3;
bool c = (a == b); // c的值为false

不相等运算符（！=）用于比较两个值是否不相等。如果它们不相等，则返回true，否则返回false。

e.g.

int a = 5;
int b = 3;
bool c = (a != b); // c的值为true

（2）大于和小于运算符

大于运算符（>）用于比较第一个操作数是否大于第二个操作数。如果是，则返回true，否则返回false。

e.g.

int a = 5;
int b = 3;
bool c = (a > b); // c的值为true

小于运算符（<）用于比较第一个操作数是否小于第二个操作数。如果是，则返回true，否则返回false。

e.g

int a = 5;
int b = 3;
bool c = (a < b); // c的值为false

（3）大于等于和小于等于运算符

大于等于运算符（>=）用于比较第一个操作数是否大于或等于第二个操作数。如果是，则返回true，否则返回false。

e.g.

int a = 5;
int b = 3;
bool c = (a >= b); // c的值为true

小于等于运算符（<=）用于比较第一个操作数是否小于或等于第二个操作数。如果是，则返回true，否则返回false。

e.g.

int a = 5;
int b = 3;
bool c = (a <= b); // c的值为false

3. 逻辑运算符

逻辑运算符用于执行布尔逻辑操作。下表列出了C++中支持的逻辑运算符：

其中，a和b代表要进行逻辑运算的两个布尔值。

（1）逻辑与运算符

逻辑与运算符（&&）用于检查两个条件是否都为真。只有当两个条件都为真时，才会返回true，否则返回false。

e.g.

bool a = true;
bool b = false;
bool c = (a && b); // c的值为false

（3）逻辑非运算符

逻辑非运算符（!）用于翻转一个布尔值。如果输入为true，则返回false，否则返回true。

e.g.

bool a = true;
bool b = !a; // b的值为false

4. 按位运算符

按位运算符用于操作二进制数据。下表列出了C++中支持的按位运算符：

其中，a和b代表要进行按位运算的两个整数。

（1）按位与运算符

按位与运算符（&）将两个二进制数的每一位进行比较，并且如果两位都为1，则该位输出1，否则输出0。

e.g.

int a = 5; // 二进制表示为101
int b = 3; // 二进制表示为011
int c = a & b; // c的值为1，二进制表示为001

（2）按位或运算符

按位或运算符（|）将两个二进制数的每一位进行比较，并且如果任意一位为1，则该位输出1，否则输出0。

e.g.

int a = 5; // 二进制表示为101
int b = 3; // 二进制表示为011
int c = a \| b; // c的值为7，二进制表示为111

（3）按位异或运算符

按位异或运算符将两个整数的二进制表示进行“异或”操作，并返回一个新的整数。当两个比特位相同时，该比特位结果为 0，否则为 1。

e.g.

int a = 5; // 二进制 101
int b = 3; // 二进制 011
int c = a ^ b; // 二进制 110 (即十进制 6)

（4）按位取反运算符

按位取反运算符对整数的二进制表示进行取反操作，并返回一个新的整数。当一个比特位为 0 时，结果为 1，否则为 0。

e.g

int a = 5; // 二进制 101
int b = ~a; // 二进制 010 (即十进制 2)

（5）左移位运算符

左移位运算符将一个整数的二进制表示向左移动指定的位数，并返回一个新的整数。左移 n 位相当于将这个数乘以 2 的 n 次方。

e.g.

int a = 5; // 二进制 101
int b = a << 1; // 二进制 1010 (即十进制 10)

（6）右移位运算符

右移位运算符将一个整数的二进制表示向右移动指定的位数，并返回一个新的整数。右移 n 位相当于将这个数除以 2 的 n 次方。

e.g.

int a = 5; // 二进制 101
int b = a >> 1; // 二进制 10 (即十进制 2)

5. 取地址运算符

C++中，取地址运算符用于获取变量或对象的内存地址，表示为&，并且可以应用于任何变量、指针或对象。使用取地址运算符可以在程序中有效地管理内存和数据结构。

取地址运算符的一般语法如下：

&variable // 获取变量的地址

&object // 获取对象的地址

&type // 获取类型的地址

其中，“variable”表示要获取地址的变量，“object”表示要获取地址的对象，“type”表示要获取地址的类型。

e.g.

int a = 10;
int* ptr = &a; // 使用取地址运算符获取变量a的地址，并将其存储在指针ptr中

cout << "The value of a is: " << a << endl;
cout << "The address of a is: " << &a << endl;
cout << "The value of ptr is: " << ptr << endl;
cout << "The value pointed to by ptr is: " << *ptr << endl;

上述代码首先定义一个整数变量“a”，然后使用取地址运算符&获取它的地址，并将其存储在指针“ptr”中。接下来打印出变量“a”的值和地址、指针“ptr”的值以及指针所指向的值。

输出结果应该与以下内容类似：

The value of a is: 10
The address of a is: 0x7fff5fbff7dc
The value of ptr is: 0x7fff5fbff7dc
The value pointed to by ptr is: 10

从输出结果可以看出，变量“a”的地址与指针“ptr”的值相同，并且指针所指向的值与变量“a”的值相同。

6. 取内容运算符

在C++中，取内容运算符用于获取指针所指向的值，表示为*，并且可以应用于任何指针变量。

取内容运算符的一般语法如下：

*pointer // 获取指针所指向的值

其中，“pointer”表示要获取值的指针变量。

e.g.

int a = 10;
int* ptr = &a; // 使用取地址运算符获取变量a的地址，并将其存储在指针ptr中

cout << "The value of a is: " << a << endl;
cout << "The value pointed to by ptr is: " << *ptr << endl;

上述代码首先定义一个整数变量“a”，然后使用取地址运算符&获取它的地址，并将其存储在指针“ptr”中。接下来打印出变量“a”的值和指针“ptr”所指向的值。

输出：

The value of a is: 10
The value pointed to by ptr is: 10

从输出结果可以看出，指针“ptr”所指向的值与变量“a”的值相同。

7. 成员选择符

在C++中，成员选择符用于访问类的成员变量和成员函数。它表示为.（点号），并且可以应用于任何已定义的对象。使用成员选择符可以操作和修改对象的成员，从而实现面向对象编程。

成员选择符的一般语法如下：

object.member // 访问成员变量或成员函数

其中，“object”表示要访问成员的对象，“member”表示要访问的成员变量或成员函数。

e.g.

class MyClass {
public:
  int myVar;
  void myFunc() {
    cout << "Hello, world!" << endl;
  }
};

MyClass obj; // 创建MyClass对象

obj.myVar = 42; // 使用成员选择符访问myVar成员变量
cout << "The value of myVar is: " << obj.myVar << endl;

obj.myFunc(); // 使用成员选择符调用myFunc成员函数

上述代码首先定义了一个名为“MyClass”的类，该类包含一个整数类型的成员变量“myVar”和一个无参数无返回值的成员函数“myFunc”。接下来创建了一个名为“obj”的MyClass对象，并使用成员选择符访问其成员变量和成员函数。

输出：

The value of myVar is: 42
Hello, world!

从输出结果可以看出，我们成功地使用成员选择符访问了MyClass对象的成员变量和成员函数。

成员选择符 -> 用于访问结构体和类指针所指向的成员。它通常与动态内存分配函数 new 结合使用，来创建对象并进行操作。

e.g.

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

int main() {
    // 创建Person结构体指针p
    Person *p = new Person();

    // 通过成员选择符->访问p所指向的name成员变量
    p->name = "John";

    // 通过成员选择符->访问p所指向的age成员变量
    p->age = 30;

    delete p;
    return 0;
}

上述代码在动态内存中分配了一个新的Person结构体，并将其作为指针p进行访问。然后使用成员选择符 -> 访问指针p所指向的name和age成员。

需要注意的是，当使用普通对象（即不是指针）时，必须使用句点 . 而不是 -> 来访问成员。

8. 作用域运算符

C++的作用域运算符 :: 用于访问类、命名空间、结构体或枚举类型中的成员，以及访问全局变量和函数。

C++可以使用作用域运算符来区分同名的成员或变量，并指定需要访问的特定成员或变量。例如，当一个类的成员与它的父类具有相同的名称时，我们可以使用作用域运算符来访问这个类所定义的成员，而不是其父类中的成员。此外，在多个源文件中实现相同的函数时，可以使用作用域运算符来分隔全局命名空间和局部命名空间。

e.g. 访问类的成员

class A {
public:
    int x;
};

class B : public A {
public:
    int x;
};

int main() {
    B b;
    b.A::x = 5; // 访问A类中的x成员
    b.x = 10;   // 访问B类中的x成员

    return 0;
}

e.g. 访问命名空间中的变量或函数：

namespace MyNamespace {
    int x = 5;

    void printX() {
        std::cout << "x = " << x << std::endl;
    }
}

int main() {
    MyNamespace::printX(); // 访问MyNamespace中的printX函数
    std::cout << "MyNamespace::x = " << MyNamespace::x << std::endl; // 访问MyNamespace中的x变量

    return 0;
}

e.g. 访问全局变量：

int x = 10;

int main() {
    int x = 5;
    std::cout << "局部变量x = " << x << std::endl;

    std::cout << "全局变量x = " << ::x << std::endl; // 访问全局命名
}

以上就是一文总结C++运算符的使用方法的详细内容，更多关于C++ 运算符的资料请关注aitechtogether.com其它相关文章！