Есть ли способ вызвать функцию-член без оператора. * Или — & gt; *

Я не совсем уверен, что вы спрашиваете. Не существует «искусственного ограничения» на вызов функций через указатели на члены; вам просто нужно использовать правильный синтаксис:

(d.*f)(5);  // for objects or references
(p->*f)(5); // for pointers

bind не делает никакой «магии»; где-то в своей реализации, он делает именно это.

в конце дня это функция, которая принимает два аргумента

Нет, это функция-член, которая принимает один аргумент и вызывается для объекта. Хотя концептуально это похоже на функцию, принимающую два аргумента, есть одно большое отличие: функции-члены могут быть виртуальными, включая механизм диспетчеризации во время выполнения.

Единственный способ, который я вижу, — заменить указатель на функцию typedef-ed классом, который ведет себя как функция.

Вы ищете что-то подобное?

В следующем коде я использовал макрос для определения типа шаблона, который затем работает как функция, которую вы описали.

#include <iostream>
using namespace std;

class D {
public:
void foo ( int a ) {
cout << "D" << endl;
}

int data;
};

template<class Object, class Param, class Function>
class FunctionPointerHelper
{
private:
Function m_function;
public:
FunctionPointerHelper(Function function) :
m_function(function)
{
}
void operator=(Function function)
{
m_function = function;
}
void operator()(Object& object, Param param) const
{
(object.*m_function)(param);
}
};

#define TYPEDEF_NICE_FUNCTION(RESULT, CLASS, NEW_TYPENAME, PARAM) \
typedef RESULT ( CLASS::* NEW_TYPENAME_INTERMEDIATE)(PARAM) ; \
typedef FunctionPointerHelper<CLASS, PARAM, NEW_TYPENAME_INTERMEDIATE> NEW_TYPENAME;

TYPEDEF_NICE_FUNCTION(void, D, Func, int)

int main ( void )
{
D d;

Func f = &D::foo;
f(d, 5);

return 1;
}

Есть ли способ вызвать функцию-член класса без объекта класса с левой стороны?

Два способа без сборки:

#include <iostream>
using namespace std;

class D {
public:
void foo ( int a ) {
cout << "D" << endl;
}

static void foo(D& d, int a)
{
d.foo(a);
}

int data;
};

void foo(D& d, int a)
{
d.foo(a);
}

int main ( void )
{
D d;

D::foo(d, 5);
foo(d, 5);

return 0;
}

но должен быть способ избежать этого искусственного ограничения
навязанный с ++

Что вы подразумеваете под «искусственное ограничение»? Это просто синтаксис, как его определяет язык. Что с этим не так? «Магия» bind() будет использовать ->* Оператор внутри, чтобы вызвать функцию.

Да, в стандарте C ++ 11 есть абстракция, называемая ВЫЗОВ который относится к вызываемым объектам. Объекты указателя на функцию-члена (PTMF) могут вызываться и this передается как первый (обычный) аргумент.

Здесь нет std::invoke функция, хотя это было предложено. Чтобы получить функтор от любого объекта Callable, вы можете использовать std::bind, который является производным от Boost.bind.

Это отлично работает:

int main ( void )
{
D d;

auto f = std::bind( &D::foo, _1, _2 );
f(&d, 5);
}

http://ideone.com/VPWV5U

Да, это правда, что с достаточным количеством искажений вы можете избежать синтаксиса «новой» функции-члена, но я должен спросить: с чего бы вы? Синтаксис способствует пониманию того, что функция-член каким-то образом вызывается из окружающего объекта. Учитывая существование виртуальных функций, это действительно (и должно быть) так. Он также автоматизирует указатель this, который требует вызова виртуальных функций (и поддержки виртуального наследования).

Для иллюстрации того, как вы можете сделать это, посмотрите на реализацию библиотеки FastDelegate. Для его реализации необходимо знать двоичную структуру указателей на функции-члены вашего компилятора (которых может быть несколько разновидностей). Это «взлом», который вы ищете. Делегаты FastDelegate (т.е. замыкания) превращаются в две инструкции в точке вызова: переносят вычисленное значение this в правильное место (на основе соглашения о вызовах) и косвенно переходят к фактическому адресу входа функции.

Это в конечном итоге выглядит так:

fastdelegate::FastDelegate0<> functionObject;
SomeClass someInstance;

//fill in object and function information in function object
functionObject.bind(&someInstance,&SomeClass::someFunction);

//call function via object.  Equivalent to: someInstance->someFunction();
functionObject();

Это очень похоже на то, что делают boost :: bind и друзья, но в целом быстрее (хотя, очевидно, менее переносимо).

Под шаблонами и перегрузкой операторов, используемых здесь, есть некоторая математика (внутри функции связывания), которая выясняет, как изменить &someInstance в указатель this, необходимый для SomeClass :: someInstance. Он также находит фактический адрес базовой функции и записывает оба значения для последующего использования. Когда вызов происходит, он заставляет компилятор «делать правильные вещи» с помощью некоторой хитрости, используя ->*, Но, если вы действительно хотите избежать даже полагаться на ->* Оператор, который вы могли бы, в этот момент, сделать несколько типов приведений и превратить указатель в указатель функции «__thiscall» (хорошо, если вы находитесь в Windows):

Соглашение о вызовах __thiscall используется для функций-членов и
соглашение о вызовах по умолчанию, используемое функциями-членами C ++, которые делают
не использовать переменные аргументы. При __thiscall вызываемый абонент очищает
стек, что невозможно для функций vararg. Аргументы выдвигаются
в стеке справа налево, с указателем this
через регистр ECX, а не в стеке, на архитектуре x86.

Итак, что именно вам не понравилось: someInstance-> someFunction ()?

Стандарт необычайно ясен и совершенно однозначен в этом вопросе. Первое предложение раздела 5.2.2 (C ++ 11) гласит:

Существует два вида вызова функций: обычный вызов функции и вызов функции-члена.

И это все — это разные вещи, и вы не можете их перепутать.