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-613391.html

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

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

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

相关文章

  • 三、C++运算符(2)算数运算符

    运行结果:

    2024年01月23日
    浏览(53)
  • C++,运算符重载——关系运算符练习

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

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

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

    2024年02月21日
    浏览(49)
  • C++ 运算符

    运算符是一种告诉编译器执行特定的数学或逻辑操作的符号。C++ 内置了丰富的运算符,并提供了以下类型的运算符: 算术运算符 关系运算符 逻辑运算符 位运算符 赋值运算符 杂项运算符 本章将逐一介绍算术运算符、关系运算符、逻辑运算符、位运算符、赋值运算符和其他

    2024年02月08日
    浏览(37)
  • c++ %运算符

    运算符%俗称“取余”或“取模”运算符,负责计算两个整数相除所得的余数。 在除法运算中,如果两个运算对象的符号相同则商为正(如果不为0的话),否则商为负。C++语言的早期版本允许结果为负值的商向上或向下取整, C++11新标准则规定商一律向0取整(即直接切除小数部分

    2024年02月19日
    浏览(46)
  • C++ 条件运算符 ? :

    其中,Exp1、Exp2 和 Exp3 是表达式。请注意冒号的使用和位置。? : 表达式的值取决于 Exp1 的计算结果。如果 Exp1 为真,则计算 Exp2 的值,且 Exp2 的计算结果则为整个 ? : 表达式的值。如果 Exp1 为假,则计算 Exp3 的值,且 Exp3 的计算结果则为整个 ? : 表达式的值。 ? 被称为三元运

    2024年02月11日
    浏览(42)
  • C++:重载运算符

    1.重载不能改变运算符运算的对象个数 2.重载不能改变运算符的优先级别 3.重载不能改变运算符的结合性 4.重载运算符必须和用户定义的自定义类型的对象一起使用,其参数至少应该有一个是类对象,或类对象的引用 5.重载运算符的功能要类似于该运算符作用于标准类型数据

    2024年02月10日
    浏览(51)
  • C++——运算符重载

    运算符重载,就是对已有的运算符重新进行定义,赋予其另一种功能,以适应不同的数据类型。 运算符重载的目的是让语法更加简洁 运算符重载不能改变本来寓意,不能改变基础类型寓意 运算符重载的本质是另一种函数调用(是编译器去调用) 这个函数统一的名字叫opera

    2024年02月16日
    浏览(53)
  • c++基础-运算符

    目录 1关系运算符 2运算符优先级 3关系表达式的书写 代码实例: 下面是面试中可能遇到的问题: C++中有6个关系运算符,用于比较两个值的大小关系,它们分别是: 运算符 描述 == 等于 != 不等于 小于 大于 = 小于等于 = 大于等于 这些运算符返回一个布尔值,即 true 或 false 。

    2024年02月02日
    浏览(57)
  • 【C++】运算符重载

    目录 1. 基本概念 1.1 直接调用一个重载的运算符函数 1.2 某些运算符不应该被重载 1.3 使用与内置类型一致的含义 1.4 赋值和复合赋值运算符 1.5 选择作为成员或者非成员 2. 输入和输出运算符 2.1 输出运算符重载 2.2 输入运算符重载 3. 算术和关系运算符 3.1 算数运算符重载 3.2

    2024年02月11日
    浏览(48)

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

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

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

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

二维码1

领取红包

二维码2

领红包