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

这篇具有很好参考价值的文章主要介绍了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.toymoban.com/news/detail-693614.html

到了这里,关于C++ 中的“&”、“*”、“.”、“->”、“:”和“::”运算符介绍的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • python中有哪些运算符,python里的运算符号

    大家好,给大家分享一下python中有哪些运算符,很多人还不知道这一点。下面详细解释一下。现在让我们来看看! 1. 比较运算符: 如果比较式成立,返回True;不成立,则返回False。 常见的比较运算符如下: 除了简单的两值相比之外,比较运算符还支持比较复杂的比较。 (

    2024年02月07日
    浏览(42)
  • Python 中的 `and`, `or`, `not` 运算符:介绍与使用

    Python 中的逻辑运算符 and , or , not 主要用于进行布尔运算。这些运算符非常有用,特别是在条件判断和循环中。 and 运算符用于检查两个(或多个)表达式是否都为 True 。 值得注意的是, and 运算符是短路的,即如果第一个表达式为 False ,则不会检查后面的表达式。 or 运算符

    2024年02月03日
    浏览(54)
  • latex 常用数学符号(积分、大型运算符、上下标)

    符号 latex ∫ 1 3 e 3 / x x 2   d x intlimits_{1}^{3}frac{e^3/x}{x^2} dx 1 ∫ 3 ​ x 2 e 3 / x ​   d x intlimits_{1}^{3}frac{e^3/x}{x^2} dx ∫ 1 3 e 3 / x x 2   d x int_{1}^{3}frac{e^3/x}{x^2} dx ∫ 1 3 ​ x 2 e 3 / x ​   d x int_{1}^{3}frac{e^3/x}{x^2}, dx ∫ − N N e x d x textstyle intlimits_{-N}^{N} e^x dx − N ∫ N ​

    2024年02月14日
    浏览(40)
  • 从0开始学Java:运算符(Operator)与标点符号(Separators)

    运算符: 是一种特殊的符号,用以表示数据的运算、赋值和比较等。 表达式: 用运算符连接起来的式子 在Java中,一共有38个运算符。 按照功能划分: 分类 运算符 算术运算符 + 、 - 、 * 、 / 、 % 、 ++ 、 -- 赋值运算符 = 、 += 、 -= 、 *= 、 /= 、 %= 等 关系运算符 、 = 、 、

    2024年02月08日
    浏览(48)
  • 入门人工智能 —— 学习一门编程语言 python 基础代码编写和运算符介绍(1)

    随着人工智能技术的快速发展,越来越多的年轻人开始关注这个领域。作为入门者,学习人工智能编程语言至关重要。这里将介绍人工智能编程语言Python的基础知识,帮助初学者更好地理解人工智能领域的基本概念和技术。 下面是一些入门 Python 编程语言的基本知识: 安装

    2024年02月09日
    浏览(60)
  • 【C++】详解运算符重载,赋值运算符重载,++运算符重载

    目录 前言 运算符重载 概念 目的 写法 调用 注意事项 详解注意事项 运算符重载成全局性的弊端 类中隐含的this指针 赋值运算符重载 赋值运算符重载格式 注意点 明晰赋值运算符重载函数的调用 连续赋值 传引用与传值返回 默认赋值运算符重载 前置++和后置++重载 先梳理一下

    2024年04月25日
    浏览(75)
  • C++,运算符重载——关系运算符练习

    一、关系运算符重载 = = == !=  二、知识点整理  

    2024年02月11日
    浏览(41)
  • 三、C++运算符(2)算数运算符

    运行结果:

    2024年01月23日
    浏览(49)
  • 【C++】中类的6个默认成员函数 取地址及const成员函数 && 学习运算符重载 && 【实现一个日期类】

    1.1 运算符重载【引入】 C++为了增强代码的可读性引入了 运算符重载 ,运算符重载是具有特殊函数名的函数,也具有其返回值类型,函数名字以及参数列表,其返回值类型与参数列表与普通的函数类似。 函数名字为: operator后面接需要重载的运算符符号。 函数原型:

    2024年02月21日
    浏览(47)
  • 【C++学习】类和对象 | 拷贝构造 | 探索拷贝构造函数为什么需要引用传参 | 深拷贝 | 初识运算符重载

    上一篇文章我们开始学习类内的默认成员函数, 这里是传送门,有兴趣可以去看看:http://t.csdn.cn/iXdpH 这篇文章我们继续来学习类和对象的知识。 目录 写在前面: 1. 拷贝构造 2. 拷贝构造函数为什么需要引用传参? 3. 深拷贝 4. 初识运算符重载 写在最后: 我们在创建一个对

    2024年02月11日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包