C++で部分適用的な書き方は出来ますか？

Question

昔ながらのプログラミング言語で新しい考え方を取り入れられないかを考えています。
部分適用的なことをC++で出来ないかを考えてみました。
まず、C#で試みました。

using System;

class Part{
  int X;
  int _add(int y){
    return X+y;
  }
  public Func<int,int>add(int x){
    X=x;
    return _add;
  }
}

class MainClass {
  static void Main() {
    
    Part part1=new Part();
    Part part2=new Part();
    
    Func<int,int>p1=part1.add(10);
    Func<int,int>p2=part2.add(100);
    
    Console.WriteLine(p1(1000));
    Console.WriteLine(p2(10000));
  }
}

とりあえず、動作はしました。
これと同じ手法でC++でやってみました。

#include<stdio.h>
typedef int(*t_add)(int);
 
class Part{
  int X;
  int _add(int y){
   return X+y;
  }
  public:t_add add(int x){
    X=x;
    return _add;　// コンパイルエラー
  }
};

int main(){

   Part *part1=new Part();
   Part *part2=new Part();

   t_add p1=part1->add(10);
   t_add p2=part2->add(100);

   printf("%d\n",p1(1000));
   printf("%d\n",p2(10000));

   return 0;
}

11行目でコンパイルエラーが発生しましたが、型を合わせる方法が分かりませんでした。
うまく、型を合わせるか、それが無理なら別の方法で解決したいのですが、アドバイスをお願いします。

Answer 1

現在の C++ のライブラリには部分適用のための std::bind という関数が用意されています。 これを用いれば部分適用したい関数 (クラス) に特別な機能を用意しておかなくてもよく、より汎用性のあるコードに出来ます。

質問中のコードを書き換えるとするとこう書けます。

#include <functional>
#include <iostream>

int main(void){
   auto part1 = std::plus<int>();
   auto part2 = std::plus<int>();

   using namespace std::placeholders;
   auto p1 = std::bind(part1, 10, _1);
   auto p2 = std::bind(part2, 100, _1);

   std::cout << p1(1000) << std::endl;
   std::cout << p2(10000) << std::endl;

   return 0;
}

Answer 2

こんにちは。

C++では、関数は容易に取り扱えますが非staticなメンバー関数の取り扱いは面倒です。
メンバー変数と関数ポインタの２つをハンドリングしないと行けないため、取り扱い辛いのです。

しかし、ファンクターなら、オブジェクトへのポインタだけハンドリングすれば良く取り扱いが簡単ですので、このようなケースではファンクターを使うとスムーズに記述できます。

サンプルです。（メモリ・リークがどうも気持ち悪いのでmain()関数も修正していますが、元のmain()関数でも動きます。）

#include<stdio.h>
#include<functional>

class t_add
{
    int X;
public:
    t_add(int x) : X(x) { }
    int operator()(int y)
    {
        return X+y;
    }
};

class Part{
  public:t_add add(int x){
    return t_add(x);
  }
};

int main(){

   Part part1;
   Part part2;

   t_add p1=part1.add(10);
   t_add p2=part2.add(100);

   printf("%d\n",p1(1000));
   printf("%d\n",p2(10000));

   return 0;
}

wandbox

見ての通り、本当はPartで実装したいことをt_addでやってますので、実は下記でも同じように機能します。

t_add p3(10);
printf("%d\n",p3(1000));

以前、カリー化の質問で部分適用するC++コードを書いてます。テンプレートとラムダ式を同時に使っているので分かりにくいとは思いますが、参考になるかも知れません。

Answer 3

ラムダ式を使うと良いかと思います。

#include <iostream>

int main(void) {
    auto p1 = [x=10](int y) { return x + y; };
    auto p2 = [x=100](int y) { return x + y; };
    
    std::cout << p1(1000) << "\n"
              << p2(10000) << "\n";
}

Answer 4

みなさん、御教授頂きありがとうございます。
C言語では出来ないものかも考えてみました。
カリー化は無理のようですが、部分適用のような感じには、出来るようです。

#include<stdlib.h>
#include<stdio.h>

#define F(f,p,x)p->f(p,x)

typedef int T;
typedef T(*t_add)(void*,T);
typedef t_add(*t__add)(void*,T);

typedef struct part{
  T X;
  t_add _add;
  t__add add;
}*Part;

T _add(Part p,T y){
  return p->X+y;
}
t_add add(Part p,T x){
  p->X=x;
  return(t_add)_add;
}

Part new_Part(){
  Part p=(Part)malloc(sizeof(struct part));
  p->_add=(t_add)_add;
  p->add=(t__add)add;
  return p;
}

int main(){
  
   Part part1=new_Part();
   Part part2=new_Part();

   t_add p1=F(add,part1,10);
   #define P1(x)p1(part1,x)

   t_add p2=F(add,part2,100);
   #define P2(x)p2(part2,x)
   
   printf("%d\n",P1(1000));
   printf("%d\n",P2(10000));
   
   free(part1);
   free(part2);
   
   return 0;
}

Answer 5

回答にならないかもですが、
C++11以降なら std::function だったかな。
それが提供されています。

ヒント1: cppreference.com

これを使えば行けそう...ですかね。

あと、モダンなC++でやるなら、typedefじゃなくて using のほうがいいらしいです。
ヒント2: C++11ではtypedefはオワコン

また、(私は使い慣れていないですが) 生ポインタは使わずに、いわゆるスマポ(スマートポインタ)と言われる、weak_ptr とか shared_ptr 等を使うのが主流のようです。
ヒント3: スマートポインタを使ってみる - std::shared_ptr - - 大雨のち大晴れ

つまり、C++11以降 (C++11, C++14, C++17 ... ) として使えば可能な場合がありますね。

Answer 6

第５７章　メンバ関数ポインタ天国 this の分を忘れているからだと思います。