web-dev-qa-db-ja.com

クラスデータメンバー「:: *」へのポインター

私はうまくコンパイルするこの奇妙なコードスニペットに出会いました：

class Car
{
    public:
    int speed;
};

int main()
{
    int Car::*pSpeed = &Car::speed;
    return 0;
}

なぜ C++には、クラスの非静的データメンバーへのこのポインターがありますか？ 何実際のコードでこの奇妙なポインターを使用していますか？

c++classpointersc++-faq
212
Ashwin Nanjappa

「メンバーへのポインター」です-次のコードはその使用方法を示しています。

#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;
}

whyについては、そうすることで、トリッキーな問題を解決できる別のレベルの間接性が得られます。しかし、正直に言うと、自分のコードでそれらを使用する必要はありませんでした。

編集：メンバーデータへのポインターの説得力のある使用を思いがけないことは考えられません。メンバ関数へのポインタは、プラガブルアーキテクチャで使用できますが、もう一度小さなスペースで例を作成することは私を打ち負かします。以下が私のベスト（テストされていない）試行です-ユーザーが選択したメンバー関数をオブジェクトに適用する前に事前＆後処理を行う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演算子は関数呼び出し演算子よりも優先順位が低いため、->*を囲む括弧が必要です。

169
anon

これは私が考えることができる最も単純な例であり、この機能が関連するまれなケースを伝えています。

#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関数を別々に記述する必要がなくなります。

70
John McFarlane

別のアプリケーションは侵入型リストです。要素タイプは、次/前のポインタが何であるかをリストに伝えることができます。したがって、リストはハードコーディングされた名前を使用しませんが、既存のポインターを使用できます。

// 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);
}
56
Johannes Schaub - litb

後でanyインスタンスでこのメンバーにアクセスできます。

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++の純粋な基本クラス）を使用する方が、より良い設計の選択肢です。

35
peterchen

信号処理/制御システムから、私が現在取り組んでいる実世界の例を以下に示します。

収集しているデータを表す構造があるとします。

struct Sample {
    time_t time;
    double value1;
    double value2;
    double value3;
};

次に、それらをベクトルに詰めると仮定します。

std::vector<Sample> samples;
... fill the vector ...

ここで、サンプルの範囲にわたって変数の1つの関数（平均など）を計算し、この平均計算を関数に因数分解するとします。メンバーへのポインターはそれを簡単にします：

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の1つのインスタンスがキャッシュラインを埋めます。したがって、ループの各反復で、1つのサンプルがメモリからキャッシュにプルされます。キャッシュラインから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値がメモリからロードされると、次の3つの値もキャッシュにロードされます（適切なアライメントが想定されます）。つまり、次の3回の反復で値をロードする必要はありません。

上記のアルゴリズムは、SSE2アーキテクチャなどでSIMD命令を使用することで、さらに改善できます。ただし、これらは機能しますmuchメモリ内の値がすべて連続しており、1つの命令を使用して4つのサンプルを一緒に読み込むことができる場合（より後のSSEバージョンで）.

YMMV-アルゴリズムに合わせてデータ構造を設計します。

34
Tom

IBM には、これを使用する方法に関するドキュメントがいくつかあります。簡単に言えば、クラスへのオフセットとしてポインターを使用しています。これらのポインターは、それらが参照するクラスとは別に使用できないため、次のようになります。

  int Car::*pSpeed = &Car::speed;
  Car mycar;
  mycar.*pSpeed = 65;

少しあいまいに思えますが、一般的なデータを多くの異なるオブジェクトタイプにデシリアライズするためのコードを作成しようとしており、コードがまったく知らないオブジェクトタイプを処理する必要がある場合（たとえば、コードがライブラリ内にあり、デシリアライズするオブジェクトはライブラリのユーザーによって作成されました）。メンバーポインターを使用すると、型のないvoid *を使用してC構造体の方法をトリックすることなく、個々のデータメンバーオフセットを参照するための一般的でわかりやすい方法が提供されます。

26
AHelps

メンバー変数と関数を統一された方法でバインドすることができます。以下はCarクラスの例です。より一般的な使用法は、STLアルゴリズムで使用するときに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;
}
18
Alex B

（同種の）メンバーデータへのポインターの配列を使用して、名前付きメンバー（つまりx.data）と配列添え字（つまり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;
}
8
Functastic

私がそれを使用した1つの方法は、クラスで何かを行う方法の2つの実装があり、ifステートメントを継続的に実行することなく実行時に1つを選択したい場合です.

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ステートメントよりもエレガントだと思いますが、それは私の意見です。

2
Troubadour

クラスへのポインターはrealポインターではありません。クラスは論理構造であり、メモリ内に物理的な存在はありませんが、クラスのメンバーへのポインターを作成すると、メンバーが見つかるメンバーのクラスのオブジェクトへのオフセットが与えられます。これは重要な結論を与えます：静的メンバーはどのオブジェクトにも関連付けられていないため、メンバーへのポインターは静的メンバー（データまたは関数）を指すことはできません以下を考慮してください：

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;
}

出典：The Complete Reference C++-Herbert Schildt 4th Edition

1
Arijit Dey

以下は、データメンバーへのポインターが役立つ例です。

#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
}
0
prestokeys

メンバーデータが非常に大きい場合（たとえば、別のかなり重いクラスのオブジェクト）、そのクラスのオブジェクトへの参照でのみ動作する外部ルーチンがある場合にのみ、これを実行したいと思うと思います。メンバーオブジェクトをコピーしたくないので、これを渡してください。

0
Andrew Jaffe

@anonと@Oktalistの答えにいくつかのユースケースを追加するために、メンバー関数へのポインターとメンバーデータへのポインターに関する優れた資料があります。 http://www.cs.wustl.edu/~schmidt/PDF/C++-ptmf4.pdf

0
Dragonly

構造があるとします。その構造の内部には*何らかの名前*同じ型であるが意味の異なる2つの変数があります

struct foo {
    std::string a;
    std::string b;
};

さて、コンテナにfoosの束があるとしましょう：

// 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」が一致するコンテナが返されます。すべてのキーが存在し、を持つfooにはaまたはbのいずれか、または両方があります。

0
inetknght