在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()。
在 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++中::和:, .和->的作用和区别?
作用域符解析c++入门学习篇(1)之::作用域符解析 - 知乎
C++中双冒号::的使用场景C++中双冒号::的使用场景 - 知乎
文章浏览阅读413次。编辑距离用于计算序列之间编辑距离和对齐的python模块。我需要一种方法来计算python中序列之间的编辑距离。我没有能够找到任何合适的库来实现这一点,所以我自己编写了一个。在那里似乎有许多可用于计算编辑的编辑距离库两个字符串之间的距离,但不是两个序列之间的距离。这完全是用python编写的。这种实现可能是在python中优化为更快。如果在C中实现。库API是根据difflib.sequencem..._edit distance python lib
文章浏览阅读3.8k次,点赞2次,收藏15次。antd 的upload组件是点开对话框后,按下确实就会上传,而且如果多选文件也会反复调用后端接口来完成上传。因为项目需要,所以要实现手动上传,和一次性上传多个文件(调用一次后端接口)在实现这个功能时,我翻阅了很多博客,可能是因为版本原因,很多代码都无用,最后还是通过翻阅官方文档,才最终实现。..._antd upload
文章浏览阅读246次。注意 第一步在一个文件下打开终端然后 sqlite3 student.db(创建一个数据库),然后再create stu。callback 回调函数 (只有sql为查询语句的时候,才会执行此语句)6--删除一列(sqlite3 不支持) 用下面方法。功能 :打开sqlite 数据库。功能 :关闭sqlite 数据库。基本sql命令,不以 . 夹头,db:指向sqlite句柄的指针。将新表的名字改为原来表的名字。sqlite3的基本命令。功能:执行一条sql语句。以 . 开头的命令。_sqlite 部署
文章浏览阅读1.4w次。前言canal-server同步到kafka本身是支持Kerberos方式的鉴权的,但是鉴于项目现在使用的kafka集群使用的是SASL/PLAIN的鉴权方式,所以需要对canal-server同步kafka做一下适配改造。准备kafka SASL/PLAIN鉴权的搭建我参考的这篇文章kafka SASL/PLAIN鉴权的搭建了解如何使用java向以SASL/PLAIN方式鉴权的kafk..._canal adapter kafka sasl
文章浏览阅读711次。adb(调试桥):debug工具。adb作用:借助adb工具,可以管理设备或手机模拟器状态。adb相关操作命令如下: 1. 显示系统中全部Android平台: android list targets2. 显示系统中全部AVD(模拟器): android list avd3. 创建AVD(模拟器): android create avd_android的shell命令工具:设备规范管理
文章浏览阅读769次,点赞10次,收藏7次。Centos 7.9 在线安装 VirtualBox 7.0_centos安装virtualbox
文章浏览阅读1.4w次,点赞9次,收藏10次。Autodesk卸载工具是一个专门用于Autodesk软件的卸载工具,可以自动识别电脑中的所有Autodesk软件,只需一键点击就能将Autodesk的软件完美卸载,并且不保留任何痕迹,这款卸载工具就可以帮助用户全面卸载Autodesk软件。_autodesk官方卸载工具
文章浏览阅读4.9k次。1.配置书写错误:配置文件value值引号内不能有空格,属性文件配置信息末尾不能有空格(1)打开属性文件中com.mysql.jdbc.Driver后发现多了一个空格(如下我标出了),所以写属性文件时一定别多输入多余的空格了。 jdbc.driverClassName=com.mysql.jdbc.Driver(此处有空格)(2)配置文件中的value值的" "号中前面或..._cannot find class: com.mysql.jdbc.driver
文章浏览阅读1.8k次。软件常用术语,免得你面对各种设计模式头发晕_软件术语
文章浏览阅读2.8k次。2017-08-02@erixhao 技术极客TechBoosterAI 机器学习第二篇 - 非线形回归分析。我们上文深入本质了解了机器学习基础线性回归算法后,本文继续研究非线性回归。非线性回归在机器学习中并非热点,并且较为小众,且其应用范畴也不如其他广。鉴于此,我们本文也将较为简单的介绍,并不会深入展开。非线性回归之后,我们会继续经典机器学习算法包括决策_非线性回归分析方法
文章浏览阅读164次。一、关系运算:1.等值比较: =语法:A=B操作类型:所有基本类型描述:如果表达式A与表达式B相等,则为TRUE;否则为FALSE举例:hive>select 1 from lxw_dual where 1=1;12.不等值比较: <>语法: A <> B操作类型:所有基本类型描述:如果表达式A为NULL,或者表..._josn mincol
文章浏览阅读767次。1 FI/SD 借口配置FI/SD通过tcode VKOA为billing设置过帐科目,用户可以创建自己的科目定义数据表。 科目是做到COA级的,通过KOFI/KOFK这两个condition type确定分别过帐到FI和CO凭证中。 由于PricingProc.是同Sale_sd 和fi 接口产生什么凭证?