C++ 中的“＆”、“*”、“.”、“-＞”、“:”和“::”运算符介绍

阅读本书更多章节>>>>

C++ 中的 "＆"，"*"，"."，"->"，":" 和 "::"运算符介绍

在C++中 "＆"，"*"，"."、"->"、":"和"::"都是运算符

& 取地址符、引用符、按位与运算符。

* 乘法运算符、指针解引用运算符(也称为间接寻址运算符)

. 点运算符或成员访问运算符。

-> 箭头运算符或成员指针访问运算符。

: 冒号运算符或成员初始化列表符号。

:: 作用域解析运算符或命名空间限定符。

它们的使用场景也各有不同。需要根据具体情况来选择使用哪个运算符。

"&"运算符

在C++中，&被称为取地址符或引用符号。按不同的应用场景，有多种用法，以下是其中几种常见的用法及示例说明。

1.取地址运算符：

&用于获取变量的内存地址。例如：

#include <iostream>using namespace std;int main() {    int a = 10;    int* ptr = &a;  // 取变量a的地址并赋值给指针ptr    cout << "a 的地址: " << ptr << endl;    return 0;}

2.引用类型：

&可以用于定义引用类型，即某个变量的别名。例如：

#include <iostream>using namespace std;int main() {    int a = 10;    int& ref = a;  // 定义一个引用ref，它是变量a的别名    ref = 20;     // 修改引用ref的值，也会修改变量a的值    cout << "a 的值: " << a << endl;    return 0;}

3.位运算中的按位与：

&可以用于执行按位与操作，对两个数的二进制位进行逐位的与操作。例如：

#include <iostream>using namespace std;int main() {    int a = 5;        // 二进制表示：0101    int b = 3;        // 二进制表示：0011    int result = a & b;  // 按位与操作，结果为0001（1）    cout << "按位与结果: " << result << endl;    return 0;}

4.可用作函数参数的引用传递

C++中的引用传递也称为按引用传递或引用参数。这种方式允许函数通过引用来操作原始变量，而不是通过复制变量的值。

通过引用传递函数参数，可以将一个变量作为参数传递给函数，并在函数内部直接操作该变量，而无需创建副本。

函数参数声明为引用类型（使用&符号），即可实现引用传递。

下面示例展示了C++中函数参数的引用传递：

#include <iostream>using namespace std;//函数参数声明为引用类型（使用&符号），即可实现引用传递。 void swap(int& a, int& b) {    int temp = a;    a = b;    b = temp;}int main() {    int x = 10;    int y = 20;    cout << "交换之前：" << endl;    cout << "x 的值: " << x << endl;    cout << "y 的值: " << y << endl;    swap(x, y);  // 调用swap函数，传递x和y的引用    cout << "交换之后：" << endl;    cout << "x 的值: " << x << endl;    cout << "y 的值: " << y << endl;    return 0;}

这个示例，定义了一个名为swap的函数，它接受两个引用类型的参数a和b。在main函数中，我们声明了两个变量x和y，并调用swap函数来交换它们的值。由于参数是引用类型，所以在swap函数内部对参数的修改会直接影响到原始变量x和y的值。

运行上述示例，输出将会是：

交换之前：
x 的值: 10
y 的值: 20
交换之后：
x 的值: 20
y 的值: 10

"*"运算符

在C++中，星号“*”按不同的应用场景，可以有多种用途，以下是其用法及示例说明。

1.乘法运算符：a * b;表示将a和b的值相乘，结果存储在c中。下面是示例：

#include <iostream>using namespace std;int main() {      int a = 10;      int b = 2;         // 使用星号符作为乘法运算符      int result1 = a * b;      cout << "result1 = " << result1 << endl;  // 输出 result1 = 20    return 0;  }

2.指针类型声明符：char* ptr1;表示声明一个指向字符类型的指针变量ptr1，该变量存储指向字符类型数据的内存地址。下面是示例：

#include <iostream>using namespace std;int main() {      int a = 10;         // 使用星号符作为指针类型声明符      int* ptr1 = &a;  // 声明一个指向整型变量 a 的指针      cout << "ptr1 = " << ptr1 << endl;  // 输出 ptr1 = 0x6ffe14 (取决于编译器分配的内存地址，以16进制表示)    return 0;  }

3. 指针解引用运算符/间接寻址运算符：*ptr1表示使用指针变量ptr1存储的地址，从内存中读取它所指向的值。下面是示例：

#include <iostream>using namespace std;int main() {      int a = 10;         // 使用星号符作为指针类型声明符      int* ptr1 = &a;  // 声明一个指向整型变量 a 的指针      // 使用星号符作为指针解引用运算符      cout << "*ptr1 = " << *ptr1 << endl;  // 输出 10        return 0;  }

"." 运算符

点运算符或成员访问运算符，用于访问一个对象的成员变量或成员函数。例如：

//“.” 点运算符示例#include <iostream>using namespace std;class Person {public:    string name;    int age;    void printInfo() {        cout << "name: " << name << ", age: " << age << endl;    }};int main() {    Person p;    p.name = "Tom";    p.age = 18;    p.printInfo();    return 0;}

输出结果为：

name: Tom, age: 18

在这个例子中，我们先定义了一个类 Person，它有两个成员变量 name 和 age，还有一个成员函数 printInfo()。然后在 main 函数中创建了一个 Person 类型的对象 p，通过使用 "." 运算符来给成员变量赋值，并调用成员函数进行输出。

"." 运算符有多种用法

1. 访问类的成员变量或成员函数：

#include <iostream>using namespace std;class Person {public:    std::string name;    int age;    void sayHello() { cout << "Hello, my name is " << name << "." << endl; }};int main() {Person p;p.name = "Tom";p.age = 20;p.sayHello();}

在上述示例中，我们定义了一个 Person 类，使用 "." 运算符可以访问其成员变量 name 和 age，以及成员函数 sayHello()。

2. 访问结构体的成员变量或成员函数：

#include <iostream>#include <math.h>using namespace std;struct Point {    double x;    double y;    double distance() { return sqrt(x * x + y * y); }};int main() {Point p = {3, 4};double d = p.distance();cout << "Distance: " << d <<endl;}

在上述示例中，我们定义了一个 Point 结构体，使用 "." 运算符可以访问其成员变量 x 和 y，以及成员函数 distance()。

3. 调用类的静态函数或访问静态变量：

#include <iostream>using namespace std;class MyClass {public:    static int count;    static void printCount() { cout << count << endl; }};int MyClass::count = 10; //静态变量需要在类定义外进行初始化int main() {MyClass::count++;MyClass::printCount();return 0;}

在上述示例中，我们使用 "." 运算符调用了 MyClass 类的静态函数 printCount() 和访问了其静态变量 count。

需要注意的是，在访问静态成员变量和调用静态成员函数时，不需要实例化类对象。

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

#include <iostream>using namespace std;namespace MyNamespace {    int x;    void foo() { cout << "Hello from MyNamespace!" << endl; }};int main() {MyNamespace::x = 10;MyNamespace::foo();return 0;}

在上述示例中，我们使用 "." 运算符访问了自定义命名空间 MyNamespace 中的变量 x 和函数 foo()。

在 C++ 中，"." 运算符主要用于访问类的成员和结构体的成员，以及调用静态函数和访问静态变量。另外，在命名空间中也可以使用 "." 运算符访问其成员

"->" 运算符

箭头运算符或成员指针访问运算符，用于访问指针所指向对象的成员变量或成员函数。例如：

//“->” 箭头运算符示例：

//“->” 箭头运算符示例#include <iostream>using namespace std;class Person {public:    string name;    int age;    void printInfo() {        cout << "name: " << name << ", age: " << age << endl;    }};int main() {    Person *p = new Person();    p->name = "Tom";    p->age = 18;    p->printInfo();    delete p;    return 0;}

输出结果：

name: Tom, age: 18

在这个例子中，我们使用了指针来动态分配内存并创建一个 Person 类型的对象，然后通过 "->" 运算符来给成员变量赋值，并调用成员函数进行输出。

"->"运算符有多种用法

1. 访问类的成员变量或成员函数：

#include <iostream>using namespace std;class Person {public:    std::string name;    int age;    void sayHello() { cout << "Hello, my name is " << name << "." << endl; }};int main() {Person* p = new Person();p->name = "Tom";p->age = 20;p->sayHello();return 0;}

在上述示例中，我们定义了一个 Person 类，并使用 new 关键字创建了一个指向 Person 对象的指针 p。使用 "->" 运算符可以访问其成员变量 name 和 age，以及成员函数 sayHello()。

2. 访问结构体的成员变量或成员函数：

#include <iostream>#include <math.h>using namespace std;struct Point {    double x;    double y;    double distance() { return sqrt(x * x + y * y); }};int main() {Point* p = new Point{3, 4};double d = p->distance();cout << "Distance: " << d << endl;return 0;}

在上述示例中，我们定义了一个 Point 结构体，并使用 new 关键字创建了一个指向 Point 对象的指针 p。使用 "->" 运算符可以访问其成员变量 x 和 y，以及成员函数 distance()。

3. 调用类的静态函数或访问静态变量：

#include <iostream>using namespace std;class MyClass {public:    static int count;    static void printCount() { cout << count << endl; }};int MyClass::count = 10; //静态变量需要在类定义外进行初始化int main() {MyClass* p = new MyClass();p->count++;p->printCount();return 0;}

在上述示例中，我们使用 new 关键字创建了一个指向 MyClass 对象的指针 p。使用 "->" 运算符调用了 MyClass 类的静态函数 printCount() 和访问了其静态变量 count。

在 C++ 中，"->" 运算符主要用于操作指针访问对象的成员，包括类和结构体的成员、静态函数和静态变量。由于指针是间接引用的，因此必须使用 "->" 运算符来访问指针所指向的对象的成员。

":" 运算符

冒号运算符或成员初始化列表符号，用于初始化子类构造函数中父类的成员变量。例如：

//冒号运算符示例 #include <iostream>using namespace std;class Base {public:    int value;    Base(int x) : value(x) {}};class Derived : public Base {public:    Derived(int x, int y) : Base(x), member(y) {}    int member;};int main() {    Derived d(1, 2);    cout << "Base value: " << d.value << ", Derived member: " << d.member << endl;    return 0;}

输出结果为：

Base value: 1, Derived member: 2

在这个例子中，我们先定义了一个基类 Base，它有一个成员变量 value。然后定义一个子类 Derived，它继承自 Base，并有一个额外的成员变量 member。在 Derived 的构造函数中，使用了 ":" 运算符来初始化基类的成员变量 value。

":" 运算符有多种用法

1. 用于初始化成员变量

在类的构造函数中，可以使用 ":" 运算符来初始化成员变量。例如：

#include<iostream>using namespace std;class MyClass {public:    int a,b,c; // 成员变量    MyClass(int x, int y, int z):a(x), b(y), c(z){} // 构造函数};int main() {    MyClass obj(1, 2, 3); // 创建对象并初始化成员变量    cout << "a: " << obj.a << endl;    cout << "b: " << obj.b << endl;    cout << "c: " << obj.c << endl;    return 0;}

在上面的示例中，我们定义了一个名为MyClass的类，并声明了三个成员变量a、b和c。然后我们定义了一个构造函数，使用:运算符对成员变量进行初始化。在main函数中，我们创建了一个MyClass对象obj，并将参数1、2、3传递给构造函数，这样就完成了对成员变量的初始化。

需要注意的是，在使用:运算符初始化成员变量时，成员变量的顺序应该与类定义中声明的顺序相同。

2. 用于调用父类的构造函数

如果一个子类继承自一个父类，那么在定义子类的构造函数时，可以使用 ":" 运算符来调用父类的构造函数。例如：

#include <iostream>using namespace std;class Parent {public:    Parent(int x) {        cout << "Parent constructor called with parameter " << x << endl;    }};class Child : public Parent {public:    Child(int y) : Parent(y) {        cout << "Child constructor called with parameter " << y << endl;    }};int main() {    Child c(10);    return 0;}

在这个示例中，我们定义了两个类：Parent和Child。Child是从Parent公开派生的。

在Child类的构造函数中，我们通过使用":"运算符来调用Parent类的构造函数，并将参数y传递给它。

在主函数中，我们创建了一个Child对象，并将值10传递给它。当Child对象被创建时，它会调用Child的构造函数，该构造函数又调用其父类Parent的构造函数。

将在控制台上输出

Child constructor called with parameter 10

Parent constructor called with parameter 10

3. 用于标识基类访问限定符

在派生类中，可以使用 ":" 运算符将基类的 public、protected 或 private 访问限定符进行分类。例如：

#include <iostream>using namespace std;class Base {public:    int public_var;protected:    int protected_var;private:    int private_var;};class Derived : public Base {public:    void setValues() {        public_var = 1; // 可以访问公有成员        protected_var = 2; // 可以访问保护成员        // private_var = 3; 不能访问私有成员    }};int main() {    Derived d;    d.setValues();    cout << "Public variable: " << d.public_var << endl;    // cout << "Protected variable: " << d.protected_var << endl; 不能访问    // cout << "Private variable: " << d.private_var << endl; 不能访问    return 0;}

在这个例子中，定义了两个类：Base和Derived。Derived公开继承自Base。在Derived中，定义了一个setValues函数，它可以访问Base类的公有和保护成员。通过使用":"运算符，可以指定Derived从Base中继承的成员变量的访问权限。在这种情况下，将public_var声明为公有的，而将protected_var声明为受保护的。这意味着Derived和Base之间的关系现在是一个公开继承的关系，其中Derived可以访问Base的公有成员和受保护成员，但不能访问其私有成员。在main函数中，创建了Derived的一个实例，并调用setValues函数来设置public_var和protected_var的值。然后打印出public_var的值1：

Public variable: 1

总之，":" 运算符在 C++ 中有多种用途，其中最常见的是用于初始化成员变量和调用父类的构造函数。

"::" 运算符

作用域解析运算符或命名空间限定符，用于访问命名空间、全局变量或静态成员变量。例如：

//作用域解析运算符#include <iostream>using namespace std;namespace MyNamespace {    int a = 10;}int main() {    cout << "MyNamespace::a = " << MyNamespace::a << endl;    return 0;}

输出结果为：

MyNamespace::a = 10

在这个例子中，我们首先定义了一个命名空间 MyNamespace，其中包含一个全局变量 a。然后在 main 函数中使用 "::" 运算符来访问该命名空间中的变量。

"::" 运算符的多种用法

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

#include <iostream>//using namespace std;// 自定义命名空间namespace MyNamespace {    int add(int a, int b) { return a + b; }};int main() {std::cout << "Hello World!" << std::endl; // 访问 std 命名空间中的 cout 对象int result = MyNamespace::add(2, 3); //访问自定义命名空间中的函数std::cout << "result = " << result << std::endl;return 0;}

2. 访问类中的静态成员变量或静态成员函数：

#include <iostream>using namespace std;class MyClass {public:    static int count;    static void printCount() { cout << count << endl; }};int MyClass::count = 10; //静态变量需要在类定义外进行初始化int main() {MyClass::count++;  // 访问 MyClass 类中的 count 静态成员变量MyClass::printCount(); // 访问 MyClass 类中的 printCount 静态成员函数return 0;}

3. 访问全局变量或函数：

#include <iostream>using namespace std;int global_var = 10; // 全局变量void printGlobalVar() { // 全局函数    cout << "Global variable: " << global_var << endl;}class MyClass {public:    void printGlobalVar() { // 成员函数        int global_var = 5; // 局部变量        cout << "Local variable: " << global_var << endl;        cout << "Global variable: " << ::global_var << endl; // 使用"::"运算符访问全局变量        ::printGlobalVar(); // 使用"::"运算符访问全局函数    }};int main() {    MyClass myObj;    myObj.printGlobalVar();    return 0;}

在这个例子中，定义了一个全局变量global_var和一个全局函数printGlobalVar。然后定义了一个MyClass类，并在其中定义了一个成员函数printGlobalVar。在printGlobalVar函数中，定义了一个名为global_var的局部变量，并使用"::"运算符来访问全局变量global_var和全局函数printGlobalVar。在main函数中，创建了一个MyClass对象myObj，并调用其printGlobalVar函数进行测试。运行程序后，它将打印出局部变量的值、全局变量的值以及全局函数的输出：

Local variable: 5

Global variable: 10

Global variable: 10

在上述示例中，我们可以看到 "::" 运算符被用于访问不同作用域中的变量、函数或静态成员。

附录

C++中的运算符优先级及结合性

C++ Operator Precedence - cppreference.com

C++ 运算符优先级 - C++中文 - API参考文档

C++中::和:， .和->的作用和区别? C++中::和:， .和->的作用和区别?

作用域符解析c++入门学习篇（1）之：：作用域符解析 - 知乎

C++中双冒号::的使用场景C++中双冒号::的使用场景 - 知乎

阅读本书更多章节>>>>

本文链接：https://www.kjpai.cn/zhengce/2024-03-29/150543.html，文章来源：网络cs，作者：言安琪，版权归作者所有，如需转载请注明来源和作者，否则将追究法律责任！