C ++：指向类数据成员的指针“:: *”
我碰到这个奇怪的代码片段编译罚款：
class Car { public: int speed; }; int main() { int Car::*pSpeed = &Car::speed; return 0; } 为什么 C ++有这个指向类的非静态数据成员的指针？ 这个奇怪的指针在真正的代码中有什么用？
这是一个“指向成员” – 下面的代码说明了它的用法：
#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; }
至于你为什么要这样做，那么它会给你一个间接的解决scheme，可以解决一些棘手的问题。 但说实话，我从来没有用我自己的代码中使用它们。
编辑：我不能想象一个令人信服的使用成员数据指针的手。 指向成员函数的指针可以在可插入的体系结构中使用，但是再次在小空间中生成一个例子会使我失望。 以下是我最好的（未经testing的）尝试 – 一个Apply函数，在将用户select的成员函数应用到对象之前，将执行一些预处理和后处理：
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周围的括号是必要的，因为->*运算符比函数调用运算符的优先级低。
这是我能想到的最简单的例子，它expression了这个特征相关的罕见情况：
#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函数。
另一个应用程序是侵入性列表。 元素types可以告诉列表它的next / prev指针是什么。 所以列表不使用硬编码的名称，但仍然可以使用现有的指针：
// 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); }
您可以稍后访问此成员，在任何情况下：
int main() { int Car::*pSpeed = &Car::speed; Car myCar; Car yourCar; int mySpeed = myCar.*pSpeed; int yourSpeed = yourCar.*pSpeed; assert(mySpeed > yourSpeed); // ;-) return 0; }
请注意，您确实需要一个实例来调用它，所以它不能像委托一样工作。
它很less使用，我需要它可能在我所有的年份一次或两次。
通常使用接口（即C ++中的纯基类）是更好的deviseselect。
从信号处理/控制系统中，我现在正在处理一个真实世界的例子：
假设你有一些代表你正在收集的数据的结构：
struct Sample { time_t time; double value1; double value2; double value3; };
现在假设你把它们填入vector中：
std::vector<Sample> samples; ... fill the vector ...
现在假设你想计算一个样本范围内某个variables的某个函数（比如平均值），并且你想把这个平均值计算分解成一个函数。 指针的成员可以很容易地：
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以获得更简洁的模板函数方法
当然，您可以对它进行模板化，以计算任何forward-iterator的均值，以及支持通过size_t自身除法的任何值types：
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等，那么你应该把每个variables的值连续存储在内存中。 否则，遍历整个系列将导致检索到的每个值都未命中。
考虑这个代码的性能：
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一个实例将填充caching行。 所以在循环的每一次迭代中，一个样本将从内存中被抽取到caching中。 将使用来自caching行的4个字节，其余的将被丢弃，下一次迭代将导致另一个caching未命中，内存访问等。
更好的做到这一点：
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值从内存加载时，接下来的三个值也将被加载到caching中（假设合适的alignment），这意味着在接下来的三次迭代中不需要加载任何值。
上述algorithm可以通过在例如SSE2体系结构上使用SIMD指令进一步改进。 但是，如果这些值在内存中都是连续的，并且可以使用单个指令一起加载四个采样（在稍后的SSE版本中），则这些工作会更好。
YMMV – devise你的数据结构来适应你的algorithm。
IBM还有一些关于如何使用它的文档。 简而言之，您使用指针作为类中的偏移量。 除了引用的类外，不能使用这些指针，所以：
int Car::*pSpeed = &Car::speed; Car mycar; mycar.*pSpeed = 65;
这看起来有些模糊，但是一个可能的应用是，如果你正在尝试编写用于将通用数据反序列化成许多不同的对象types的代码，并且你的代码需要处理它完全不知道的对象types（例如，你的代码是在一个库中，你反序列化的对象是由你的库的用户创build的）。 成员指针为您提供了一种通用的，半可读的方式来引用各个数据成员的偏移量，而不必像C结构那样求助于无types的void *技巧。
它可以以统一的方式绑定成员variables和函数。 以下是您的Car类的例子。 更常见的用法是在STLalgorithm中使用std::pair::first和::second ，并在地图上使用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; }
您可以使用指向（同类）成员数据的指针数组来启用双重命名成员（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(vx == 1.0f); assert(vy == 2.0f); assert(vz == 3.0f); return 0; }
我使用过的一种方法是，如果我有两个如何在类中执行某些操作的实现，并且我想在运行时select一个，而不必不断地通过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语句会减慢所做的事情， 在某个密集algorithm的深处。 即使在没有实际用途的情况下，我仍然认为它比if语句更优雅，但这只是我的观点。
我认为如果成员数据相当大（例如，另一个相当庞大的类的对象），那么只需要执行此操作，并且只有对该类的对象的引用有效的外部例程。 你不想复制成员对象，所以这可以让你传递它。
这里是一个指向数据成员的指针可能有用的例子：
#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 }
假设你有一个结构。 该结构的内部是*某种名称*两个相同types的variables，但具有不同的含义
struct foo { std::string a; std::string b; };
好吧，现在让我们假设你在容器中有一堆foo ：
// key: some sort of name, value: a foo instance std::map<std::string, foo> container;
好的，现在假设你从不同的来源加载数据，但数据是以同样的方式呈现的（例如，你需要相同的parsing方法）。
你可以做这样的事情：
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或两者兼而有之。
只是为@ anon's＆@ Oktalist的答案添加一些用例，这是关于指向成员函数的指针和指向成员数据的很棒的阅读材料。 http://www.cs.wustl.edu/~schmidt/PDF/C++-ptmf4.pdf
