C ++エクステンション関数？

C ++には拡張機能はありません。それらを自由関数として定義することができます。

uint SwapEndian(uint value){ ... }

そうではありませんが、書かなかったクラスで動作する演算子オーバーロードを書くことはできますが、メソッド拡張のようなものです（名前付き関数ではなく、すでにそのクラスによって定義されています）。古典的な例は、あなたのクラスを cout で動作させることです：

class MyClass {
public:
    MyClass(const char* blah) : str(blah) { }

    const char* string() const {
        return str;
    }

private:
    const char* str;
};

// this is kinda like a method extension
ostream& operator<<(ostream& lhs, const MyClass& rhs) {
    lhs << rhs.string();
}

// then you can use it like this
MyClass m("hey ho");
cout << m;

// prints hey ho

これはもちろんの簡単な例ですが、あなたはその考えを得る。

直接的な方法ではなく、テンプレートを使用して目的の効果を達成することができます。元のクラスから派生せずに、C ++の具象クラスにメソッドを "追加"することはできませんが、どの型でも機能する関数テンプレートを作成できます。

たとえば、整数型のntoh型変換を行うために使用する関数テンプレートライブラリを次に示します。

template inline Val ntohx(const Val& in)
{
    char out[sizeof(in)] = {0};
    for( size_t i = 0; i < sizeof(Val); ++i )
        out[i] = ((char*)&in)[sizeof(Val)-i-1];
    return *(reinterpret_cast(out));
}

template<> inline unsigned char ntohx(const unsigned char & v )
{
    return v;
}
template<> inline uint16_t ntohx(const uint16_t & v)
{
    return ntohs(v);
}

template<> inline uint32_t ntohx(const uint32_t & v)
{
    return ntohl(v);
}

template<> inline uint64_t ntohx(const uint64_t & v)
{
    uint32_t ret [] =
    {
        ntohl(((const uint32_t*)&v)[1]),
        ntohl(((const uint32_t*)&v)[0])
    };
    return *((uint64_t*)&ret[0]);
}
template<> inline float ntohx(const float& v)
{
    uint32_t const* cast = reinterpret_cast(&v);
    uint32_t ret = ntohx(*cast);
    return *(reinterpret_cast(&ret));
};

いいえ、申し訳ありませんが、C ++のようなものはありません。標準が実装依存（つまり、コンパイラは好きなやり方でそれをやり遂げることができる）として残しているものがたくさんありますし、またC ++には標準化された ABI を参照してください。

One method I have found is to use the overloaded ">>" operator with lambda expressions. The following code demonstrates this. You have to know to use operator ">>" instead of "->", this is because the compiler I use will not allow the operator "->" to be overloaded. Also because the operator ">>" has lower precedence than the "->" you have to use parentheses to force to compiler to evaluate the equation in the correct order.

最終的には、生成しようとしているコードのスタイル、保守性、信頼性、およびクリーンさの問題になります。 2つの引数を使用して "SubtractValue"メソッドを定義すると、より効率的なコードが作成されますが、オーバーロードされたメソッドはよりメンテナンス可能であると主張します。結局のところ、建築家や開発者は、プロジェクトにとって何が重要かを判断する必要があります。私は問題に可能な解決策を提供しています。

#include 
#include 
#include 
#include 

// Some plain demo class that cannot be changed.
class DemoClass
{
public:
    int GetValue() { return _value; }
    int SetValue(int ivalue) { _value = ivalue; return _value; }
    DemoClass *AddValue(int iadd) { this->_value += iadd; return this; }

private:
    int _value = 0;
};

// Define Lambda expression type that takes and returns a reference to the object.
typedef std::function DemoClassExtension;

// Overload the ">>" operator because we cannot overload "->" to execute the extension.
DemoClass* operator>>(DemoClass *pobj, DemoClassExtension &method)
{
    return method(pobj);
}

// Typical extensions.

// Subtract value "isub".
DemoClassExtension SubtractValue(int isub)
{
    return [=](DemoClass *pobj) {
        pobj->AddValue(-isub);
        return pobj;
    };
}

// Multiply value "imult".
DemoClassExtension MultiplyValue(int imult)
{
    return [=](DemoClass *pobj) {
        pobj->SetValue(pobj->GetValue() * imult);
        return pobj;
    };
}

int _tmain(int argc, _TCHAR* argv[])
{
    DemoClass *pDemoObject = new DemoClass();
    int value = (pDemoObject->AddValue(14) >> SubtractValue(4) >> MultiplyValue(2))->GetValue();
    std::cout << "Value is " << value;
    return 0;
}

上記のコード出力は "Value is 20"です。

this -qualifiedメソッドのパラメータを参照している場合は、noです。しかし、あなたの特定のユースケースに応じて、他にもいくつかの巧妙なトリックがあるかもしれません...詳細を提供できますか？