我遇到了这个编译得很好的奇怪代码片段：
class Car
{
public:
int speed;
};
int main()
{
int Car::*pSpeed = &Car::speed;
return 0;
}
为什么C++ 有这个指向类的非静态数据成员的指针？这个奇怪的指针在实际代码中有什么用？
Ash
问问题
185889 次
18 回答
223
它是一个“指向成员的指针”——下面的代码说明了它的用法：
#include <iostream>
using namespace std;
class Car
{
public:
int speed;
};
int main()
{
int Car::*pSpeed = &Car::speed;
Car c1;
c1.speed = 1; // direct access
cout << "speed is " << c1.speed << endl;
c1.*pSpeed = 2; // access via pointer to member
cout << "speed is " << c1.speed << endl;
return 0;
}
至于您为什么要这样做，它为您提供了另一个层次的间接性，可以解决一些棘手的问题。但老实说，我从来没有在自己的代码中使用过它们。
编辑：我想不出一个令人信服的使用指向成员数据的指针。指向成员函数的指针可用于可插拔架构中，但再次在狭小的空间中生成示例让我失望。以下是我最好的（未经测试的）尝试 - 在将用户选择的成员函数应用于对象之前会执行一些前后处理的 Apply 函数：
void Apply( SomeClass * c, void (SomeClass::*func)() ) {
// do hefty pre-call processing
(c->*func)(); // call user specified function
// do hefty post-call processing
}
括号c->*func是必要的，因为->*运算符的优先级低于函数调用运算符。
于 2009-03-22T09:13:24.017 回答
103
这是我能想到的最简单的示例，它传达了与此功能相关的罕见情况：
#include <iostream>
class bowl {
public:
int apples;
int oranges;
};
int count_fruit(bowl * begin, bowl * end, int bowl::*fruit)
{
int count = 0;
for (bowl * iterator = begin; iterator != end; ++ iterator)
count += iterator->*fruit;
return count;
}
int main()
{
bowl bowls[2] = {
{ 1, 2 },
{ 3, 5 }
};
std::cout << "I have " << count_fruit(bowls, bowls + 2, & bowl::apples) << " apples\n";
std::cout << "I have " << count_fruit(bowls, bowls + 2, & bowl::oranges) << " oranges\n";
return 0;
}
这里要注意的是传入count_fruit的指针。这使您不必编写单独的 count_apples 和 count_oranges 函数。
于 2011-04-29T16:05:59.073 回答
66
另一个应用是侵入式列表。元素类型可以告诉列表它的下一个/上一个指针是什么。所以列表不使用硬编码的名称，但仍然可以使用现有的指针：
// say this is some existing structure. And we want to use
// a list. We can tell it that the next pointer
// is apple::next.
struct apple {
int data;
apple * next;
};
// simple example of a minimal intrusive list. Could specify the
// member pointer as template argument too, if we wanted:
// template<typename E, E *E::*next_ptr>
template<typename E>
struct List {
List(E *E::*next_ptr):head(0), next_ptr(next_ptr) { }
void add(E &e) {
// access its next pointer by the member pointer
e.*next_ptr = head;
head = &e;
}
E * head;
E *E::*next_ptr;
};
int main() {
List<apple> lst(&apple::next);
apple a;
lst.add(a);
}
于 2009-03-23T00:19:15.787 回答
47
这是我现在正在处理的一个真实示例，来自信号处理/控制系统：
假设您有一些表示您正在收集的数据的结构：
struct Sample {
time_t time;
double value1;
double value2;
double value3;
};
现在假设您将它们填充到向量中：
std::vector<Sample> samples;
... fill the vector ...
现在假设您想计算一个变量在一系列样本上的某个函数（例如平均值），并且您想将该平均值计算分解为一个函数。指向成员的指针使它变得容易：
double Mean(std::vector<Sample>::const_iterator begin,
std::vector<Sample>::const_iterator end,
double Sample::* var)
{
float mean = 0;
int samples = 0;
for(; begin != end; begin++) {
const Sample& s = *begin;
mean += s.*var;
samples++;
}
mean /= samples;
return mean;
}
...
double mean = Mean(samples.begin(), samples.end(), &Sample::value2);
注意 2016/08/05 编辑，以获得更简洁的模板函数方法
而且，当然，您可以对其进行模板化，以计算任何前向迭代器和任何支持与自身相加和除以 size_t 的值类型的平均值：
template<typename Titer, typename S>
S mean(Titer begin, const Titer& end, S std::iterator_traits<Titer>::value_type::* var) {
using T = typename std::iterator_traits<Titer>::value_type;
S sum = 0;
size_t samples = 0;
for( ; begin != end ; ++begin ) {
const T& s = *begin;
sum += s.*var;
samples++;
}
return sum / samples;
}
struct Sample {
double x;
}
std::vector<Sample> samples { {1.0}, {2.0}, {3.0} };
double m = mean(samples.begin(), samples.end(), &Sample::x);
编辑 - 上面的代码具有性能影响
你应该注意到，正如我很快发现的那样，上面的代码有一些严重的性能影响。总结是，如果您要计算时间序列的汇总统计量，或计算 FFT 等，那么您应该将每个变量的值连续存储在内存中。否则，遍历该系列将导致每个检索到的值的缓存未命中。
考虑这段代码的性能：
struct Sample {
float w, x, y, z;
};
std::vector<Sample> series = ...;
float sum = 0;
int samples = 0;
for(auto it = series.begin(); it != series.end(); it++) {
sum += *it.x;
samples++;
}
float mean = sum / samples;
在许多架构上，一个实例Sample将填充一个缓存行。因此，在循环的每次迭代中，都会将一个样本从内存中提取到缓存中。缓存行中的 4 个字节将被使用，其余的被丢弃，下一次迭代将导致另一个缓存未命中、内存访问等。
这样做要好得多：
struct Samples {
std::vector<float> w, x, y, z;
};
Samples series = ...;
float sum = 0;
float samples = 0;
for(auto it = series.x.begin(); it != series.x.end(); it++) {
sum += *it;
samples++;
}
float mean = sum / samples;
现在，当第一个 x 值从内存中加载时，接下来的三个也将加载到缓存中（假设合适的对齐方式），这意味着您不需要为接下来的三个迭代加载任何值。
通过在例如 SSE2 架构上使用 SIMD 指令，可以进一步改进上述算法。但是，如果这些值在内存中都是连续的，并且您可以使用一条指令将四个样本一起加载（在以后的 SSE 版本中更多），则这些工作会更好。
YMMV - 设计您的数据结构以适合您的算法。
于 2010-11-02T13:17:26.407 回答
39
您可以稍后在任何实例上访问此成员：
int main()
{
int Car::*pSpeed = &Car::speed;
Car myCar;
Car yourCar;
int mySpeed = myCar.*pSpeed;
int yourSpeed = yourCar.*pSpeed;
assert(mySpeed > yourSpeed); // ;-)
return 0;
}
请注意，您确实需要一个实例来调用它，因此它不像委托那样工作。
它很少使用，我多年来可能需要它一两次。
通常使用接口（即 C++ 中的纯基类）是更好的设计选择。
于 2009-03-22T09:10:20.263 回答
26
IBM有更多关于如何使用它的文档。简而言之，您将指针用作类的偏移量。除了它们引用的类之外，您不能使用这些指针，因此：
int Car::*pSpeed = &Car::speed;
Car mycar;
mycar.*pSpeed = 65;
看起来有点晦涩，但一个可能的应用是，如果您尝试编写代码以将通用数据反序列化为许多不同的对象类型，并且您的代码需要处理它完全不知道的对象类型（例如，您的代码是在库中，并且您反序列化的对象是由您的库的用户创建的）。成员指针为您提供了一种通用的、半易读的方式来引用各个数据成员的偏移量，而不必像 C 结构那样使用无类型的 void * 技巧。
于 2009-03-22T09:13:18.133 回答
20
它使得以统一的方式绑定成员变量和函数成为可能。以下是您的 Car 类的示例。更常见的用法是绑定std::pair::first以及::second在 STL 算法和地图上的 Boost 中使用时。
#include <list>
#include <algorithm>
#include <iostream>
#include <iterator>
#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
class Car {
public:
Car(int s): speed(s) {}
void drive() {
std::cout << "Driving at " << speed << " km/h" << std::endl;
}
int speed;
};
int main() {
using namespace std;
using namespace boost::lambda;
list<Car> l;
l.push_back(Car(10));
l.push_back(Car(140));
l.push_back(Car(130));
l.push_back(Car(60));
// Speeding cars
list<Car> s;
// Binding a value to a member variable.
// Find all cars with speed over 60 km/h.
remove_copy_if(l.begin(), l.end(),
back_inserter(s),
bind(&Car::speed, _1) <= 60);
// Binding a value to a member function.
// Call a function on each car.
for_each(s.begin(), s.end(), bind(&Car::drive, _1));
return 0;
}
于 2009-03-22T13:02:42.123 回答
11
您可以使用指向（同质）成员数据的指针数组来启用双重命名成员（iexdata）和数组下标（即x[idx]）接口。
#include <cassert>
#include <cstddef>
struct vector3 {
float x;
float y;
float z;
float& operator[](std::size_t idx) {
static float vector3::*component[3] = {
&vector3::x, &vector3::y, &vector3::z
};
return this->*component[idx];
}
};
int main()
{
vector3 v = { 0.0f, 1.0f, 2.0f };
assert(&v[0] == &v.x);
assert(&v[1] == &v.y);
assert(&v[2] == &v.z);
for (std::size_t i = 0; i < 3; ++i) {
v[i] += 1.0f;
}
assert(v.x == 1.0f);
assert(v.y == 2.0f);
assert(v.z == 3.0f);
return 0;
}
于 2009-03-23T04:24:54.230 回答
2
我使用它的一种方法是，如果我有两个关于如何在一个类中做某事的实现，并且我想在运行时选择一个，而不必不断地通过 if 语句，即
class Algorithm
{
public:
Algorithm() : m_impFn( &Algorithm::implementationA ) {}
void frequentlyCalled()
{
// Avoid if ( using A ) else if ( using B ) type of thing
(this->*m_impFn)();
}
private:
void implementationA() { /*...*/ }
void implementationB() { /*...*/ }
typedef void ( Algorithm::*IMP_FN ) ();
IMP_FN m_impFn;
};
显然，如果您觉得代码被敲打到足以使 if 语句减慢某些事情的速度，例如，这实际上是有用的。在某处某个密集算法的内部深处。即使在没有实际用途的情况下，我仍然认为它比 if 语句更优雅，但这只是我的意见。
于 2009-03-22T11:57:30.563 回答
2
指向类的指针不是真正的指针；类是一个逻辑构造，在内存中没有物理存在，但是，当您构造指向类成员的指针时，它会在成员所在类的对象中提供一个偏移量；这给出了一个重要的结论：由于静态成员不与任何对象关联，因此指向成员的指针不能指向静态成员（数据或函数） 考虑以下内容：
class x {
public:
int val;
x(int i) { val = i;}
int get_val() { return val; }
int d_val(int i) {return i+i; }
};
int main() {
int (x::* data) = &x::val; //pointer to data member
int (x::* func)(int) = &x::d_val; //pointer to function member
x ob1(1), ob2(2);
cout <<ob1.*data;
cout <<ob2.*data;
cout <<(ob1.*func)(ob1.*data);
cout <<(ob2.*func)(ob2.*data);
return 0;
}
资料来源：完整参考 C++ - Herbert Schildt 第 4 版
于 2018-06-27T18:06:31.283 回答
1
我喜欢*and&运算符：
struct X
{
int a {0};
int *ptr {NULL};
int &fa() { return a; }
int *&fptr() { return ptr; }
};
int main(void)
{
X x;
int X::*p1 = &X::a; // pointer-to-member 'int X::a'. Type of p1 = 'int X::*'
x.*p1 = 10;
int *X::*p2 = &X::ptr; // pointer-to-member-pointer 'int *X::ptr'. Type of p2 = 'int *X::*'
x.*p2 = nullptr;
X *xx;
xx->*p2 = nullptr;
int& (X::*p3)() = X::fa; // pointer-to-member-function 'X::fa'. Type of p3 = 'int &(X::*)()'
(x.*p3)() = 20;
(xx->*p3)() = 30;
int *&(X::*p4)() = X::fptr; // pointer-to-member-function 'X::fptr'. Type of p4 = 'int *&(X::*)()'
(x.*p4)() = nullptr;
(xx->*p4)() = nullptr;
}
事实上，只要成员是公开的或静态的，一切都是真的
于 2021-11-01T14:38:35.663 回答
0
这是一个指向数据成员的指针可能有用的示例：
#include <iostream>
#include <list>
#include <string>
template <typename Container, typename T, typename DataPtr>
typename Container::value_type searchByDataMember (const Container& container, const T& t, DataPtr ptr) {
for (const typename Container::value_type& x : container) {
if (x->*ptr == t)
return x;
}
return typename Container::value_type{};
}
struct Object {
int ID, value;
std::string name;
Object (int i, int v, const std::string& n) : ID(i), value(v), name(n) {}
};
std::list<Object*> objects { new Object(5,6,"Sam"), new Object(11,7,"Mark"), new Object(9,12,"Rob"),
new Object(2,11,"Tom"), new Object(15,16,"John") };
int main() {
const Object* object = searchByDataMember (objects, 11, &Object::value);
std::cout << object->name << '\n'; // Tom
}
于 2015-11-18T18:48:27.413 回答
0
假设你有一个结构。该结构内部是 * 某种名称 * 两个相同类型但含义不同的变量
struct foo {
std::string a;
std::string b;
};
好的，现在假设您foo在容器中有一堆 s：
// key: some sort of name, value: a foo instance
std::map<std::string, foo> container;
好的，现在假设您从不同的源加载数据，但数据以相同的方式呈现（例如，您需要相同的解析方法）。
你可以这样做：
void readDataFromText(std::istream & input, std::map<std::string, foo> & container, std::string foo::*storage) {
std::string line, name, value;
// while lines are successfully retrieved
while (std::getline(input, line)) {
std::stringstream linestr(line);
if ( line.empty() ) {
continue;
}
// retrieve name and value
linestr >> name >> value;
// store value into correct storage, whichever one is correct
container[name].*storage = value;
}
}
std::map<std::string, foo> readValues() {
std::map<std::string, foo> foos;
std::ifstream a("input-a");
readDataFromText(a, foos, &foo::a);
std::ifstream b("input-b");
readDataFromText(b, foos, &foo::b);
return foos;
}
此时，调用readValues()将返回一个“input-a”和“input-b”一致的容器；所有键都将存在，并且 foos 具有 a 或 b 或两者兼有。
于 2016-04-12T15:08:47.250 回答
0
指向成员的真实世界示例可能是 std::shared_ptr 的更窄的别名构造函数：
template <typename T>
template <typename U>
shared_ptr<T>::shared_ptr(const shared_ptr<U>, T U::*member);
那个构造函数有什么好处
假设你有一个 struct foo：
struct foo {
int ival;
float fval;
};
如果您已将 shared_ptr 赋予 foo，则可以使用该构造函数将 shared_ptr 检索到其成员 ival 或 fval：
auto foo_shared = std::make_shared<foo>();
auto ival_shared = std::shared_ptr<int>(foo_shared, &foo::ival);
如果想将指针 foo_shared->ival 传递给一些需要 shared_ptr 的函数，这将很有用
https://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr
于 2020-09-20T15:56:05.627 回答
0
指向成员的指针是 C++ 中 C 的类型安全等价物offsetof()，它在 中定义stddef.h：两者都返回信息，其中某个字段位于 aclass或struct中。虽然offsetof()在 C++ 中也可以与某些足够简单的类一起使用，但在一般情况下它会失败，尤其是虚拟基类。所以指向成员的指针被添加到标准中。它们还提供了更简单的语法来引用实际字段：
struct C { int a; int b; } c;
int C::* intptr = &C::a; // or &C::b, depending on the field wanted
c.*intptr += 1;
比：
struct C { int a; int b; } c;
int intoffset = offsetof(struct C, a);
* (int *) (((char *) (void *) &c) + intoffset) += 1;
至于为什么要使用offsetof()（或指向成员的指针），stackoverflow 的其他地方有很好的答案。一个例子在这里：C offsetof 宏是如何工作的？
于 2021-02-20T15:45:33.597 回答
0
使用指向成员的指针，我们可以编写这样的通用代码
template<typename T, typename U>
struct alpha{
T U::*p_some_member;
};
struct beta{
int foo;
};
int main()
{
beta b{};
alpha<int, beta> a{&beta::foo};
b.*(a.p_some_member) = 4;
return 0;
}
于 2021-07-22T10:25:37.933 回答
-1
我认为如果成员数据非常大（例如，另一个相当大的类的对象），并且您有一些仅适用于对该类对象的引用的外部例程，您只想这样做。您不想复制成员对象，因此这可以让您传递它。
于 2009-03-22T10:47:02.013 回答
-1
只是为@anon 和@Oktalist 的答案添加一些用例，这里是关于指针到成员函数和指针到成员数据的很好的阅读材料。
于 2016-12-25T07:22:39.077 回答