Вызов функции из аргумента(C++)

Можно по идее использовать указатель на функцию.

Можно хранить указатель на функцию, можно std::function, можно вместо функций использовать классы, соответственно определить интерфейс твоих команд, а хранить инстансы классов унаследованных от него.

Можно. Примерно так и делают. Только mapped_type (aka rhs) должен быть не void*, а function pointer. Гуглите, ничего особо сложного там нет.

можно std::function

Человек очевидно учится, зачем ему это (еще из без понимания всех implications)? Пусть познаёт основы. Только function pointers и ничего боле.

Только function pointers

Только хардкор! Мы страдали в 70х, и он пусть страдает тоже!

Указатели на функцию в С имеют жуткий синтаксис. Но да, проще не придумаешь… можно виртуальные классы и шаблоны припахать;-)

Только хардкор!

Нет там хардкора. Если Вы такой «добрый» - удачи объяснить товарищу как std::function устроена, что именно она делает и чего стОит по сравнению с вызовом через function pointer.

Указатели на функцию в С имеют жуткий синтаксис.

typedefs спасут отца русской демократии ;)

удачи объяснить товарищу как std::function устроена

А как std::string устроена, видел? Пусть лучше char* гоняет.

А как std::string устроена, видел?

Видел. Больше чем одну реализацию.

Пусть лучше char* гоняет.

Raw pointers - отменить (только смарты), function pointers - отменить (только лямбды), циклы с индексами - отменить (только итераторы). Итд. А потом имеем то что имеем - кучу Г которое едва ворочается и жрёт как не в себя.

Дописал это для проверки

void commandExecutor::TestFunc()
{
    cout << "Hello\n";
}

...
std::function<void()> f = TestFunc;
f();

Только ошибка в TestFunc не пойму почему

function pointers - отменить (только лямбды), циклы с индексами - отменить (только итераторы). Итд

так то и лямбды и итераторы быстрее чем function pointers и циклы с индексами.

В худшем случае одинаково будет, если компилятор правильно оптимизирует…

делай функцию static, либо поменяй тип функции на void(commandExecutor*) и передавай первым аргументом указатель на экземляр класса commandExecutor.

https://gcc.godbolt.org/z/9vrKdaE61

Так ты подумай, почему. От какого объекта ты собираешься звать TestFunc() через f()?

Смотри пример: https://gcc.godbolt.org/z/aMKjG5rsd

Если Вы такой «добрый» - удачи объяснить товарищу как std::function устроена, что именно она делает и чего стОит по сравнению с вызовом через function pointer.

А чего там обяснять - одинаково стоит что так, что так. std::function отличается только наличием каста перед вызовом, который на рантайм не влияет.

Raw pointers - отменить (только смарты), function pointers - отменить (только лямбды), циклы с индексами - отменить (только итераторы). Итд. А потом имеем то что имеем - кучу Г которое едва ворочается и жрёт как не в себя.

Если писать код с головой на плечах, то оверхед от всего этого нулевой (или даже ускорение, если использовать итераторы с ассоциативными контейнерами вместо «наивного» индексирования)

(C++)

Если у тебя цпп, то никаких void* для функций быть не должно. Используй std::function. Хватит обмазываться старьём.

Потому что это не функция, а метод. Оборачивай через лямбду или std::bind. Но не проморгай время жизни объекта, в котором находится метод.

Function pointers это сишное наследие с ублюдским синтаксисом. У std::function есть оверхед, но лучше начинать с него как более высокоуровневой и можной абстракции.

Только ошибка в TestFunc не пойму почему

Не вижу ни конкретных вопросов, ни текста ошибки - если такое повториться будешь отправлен читать книгу по C++ в одиночестве.

TestFunc должен быть свободной функцией или статическим методом. Если тебе нужно звать обычные методы, очевидно что для этого как минимум нужен инстанс класса при вызове.

Стоимость вызова действительно не отличается, но std::function значительно жирнее, так как SBO.

А возможно ли всё это вызывать не в мэйне а в конструкторе? Сейчас я пытаюсь сделать так

//.h
class commandExecutor
{
private:
	map <string, std::function<void()>> AvailableCommands;
	string command;
public:
	commandExecutor();
	void TestFunc();
	
};

.cpp
commandExecutor::commandExecutor()
{
    AvailableCommands["Test"] = &commandExecutor::TestFunc;

}

AvailableCommands["Test"] = [this]{this->TestFunc();};

Поясню немного ответ rupert. commandExecutor::TestFunc это метод класса commandExecutor. В любом нестатическом методе есть неявный аргумент this, указывающий на экземпляр класса, у которого вызывается этот метод.

Таким образом, для вызова команды этот this нужно как-то передать. &commandExecutor::TestFunc это указатель на метод класса, и this там нет. Одним из вариантов решения проблемы является использование замыканий, предложенное rupert: замыкание сохраняет в себе this и вызывает функцию от него. Состояние замыкания будет скопировано в std::function, поэтому его можно будет вызывать без аргументов.

Альтернативным решением было бы вместо std::function использовать указатели на методы, что-то наподобие

std::unordered_map<std::string, int(commandExecutor::*)()> map;
map["test"] = &commandExecutor::TestFunc;

тогда для вызова this пришлось бы указывать явно

(*this.*map["test"])();

Синтаксис указателей на методы достаточно неочевидный, но их применение избавляет от необходимости хранить лишнее.

Сначала изучить C++. Указатель на функцию != void*.

используй или std::function или void(*)(args_if_needed)

Не, пусть поймёт и пользуется в продакте уже тем, что удобнее/необходимее по условиям. Динамические аллокации в std::function иногда сильно лишними становятся.

одинаково стоит что так, что так.

https://godbolt.org/z/8xY3rc8nv

Это закрывает вопрос? Или стОит обсудить почему так происходит?

fsb4000

так то и лямбды и итераторы быстрее чем function pointers и циклы с индексами.

В худшем случае одинаково будет, если компилятор правильно оптимизирует…

Наглая ложь. В лучшем случае - не хуже (когда весь статик контекст компилятору виден).

Siborgium

Стоимость вызова действительно не отличается, но std::function значительно жирнее, так как SBO.

Приведённый тривиальный (спешу заметить) пример доказывает обратное.

вводится команда, проверяется наличие ключа и после этого мне нужно запустить функцию, которая передаётся в качестве значения словаря. Как это сделать?

Использовать какую-нибудь готовую библиотеку для разбора ключей командной строки…

AvailableCommands[«Test»] = &commandExecutor::TestFunc;

Пожалуйста, не надо уродовать C++, не надо отдирать методы класса от класса! Вся сила C++ именно в ООП. В данном примере, как значение мапы, нужно хранить сам объект (или указатель на него).

Я может непопулярную вещь скажу, но не надо запихивать обработку команд в словарь std::map. Простой if-else-if-else намного выразительней и гибче. На каждую команду ты сможешь вызвать какие-то обработчики, только с теми параметрами, что ему нужны. Или обработать команду-однострочник сразу на месте. Также ты можешь сделать обработку паттернов, например cmd.startsWith(prefix). Словарь же фиксирует и обобщает интерфейс обработчиков, заставляет выносить даже тривиальные обработчики в отдельную функцию или класс. Кроме того, словарь — это элемент рантайма и дополнительный источник энтропии. Что, если он мутабельный — держи в голове, откуда он модифицируется. Что, если команда записана в словаре, но ее обработчик не установлен (nullptr) — определяй семантику, ошибка это или эквивалент отсутствия команды в словаре. Что, если обработчик команды удалён — контролируй лайфтаймы (привет, ржавая мразь).

Хоть это и может показаться тривиальным, в перспективе развития проекта множеством людей (они приходят и уходят) на длительный период, чем больше такой динамики, тем больше и больше распухает контекст и информационный шум, с которыми приходится иметь дело программистам. Я не говорю, что динамика — плохо, но у неё должна быть лучшая причина чем «чтоб было красиво».

Ну это смотря какие команды. Если они динамически формируются, то всё равно какой-нибудь контейнер понадобится

Сейчас модно string_view

смарты лямбды итераторы

Что из этого являет собой «кучу Г которое едва ворочается и жрёт как не в себя»? Ну кроме лямбд, я слышал у них какой-то минимальный оверхед есть.

Ну лямбда-то врятли будет быстрее из-за дополнительных манипуляций. Этож надо структ построить, сделать инстанс итп. Особенно если несколько раз вызывается.

Приведённый тривиальный (спешу заметить) пример доказывает обратное.

вообще не доказывает.

Вы вообще видели тот ассемблерный вывод?

Вот что он делает если перевести его обратно на C++:

void CallMe1(FuncType1 func1)
{
   if (func1 == nullptr) {
       throw bad_function_call();
   }
   func1();
}

Очевидно что если писать корректный код нужно проверять самому на nullptr func1.

Так что это не минус, а плюс. Используя std::function совершаешь меньше багов.

А если компилятор знает что передали не nullptr, то он это проверку уберёт при inline, посмотрите ассемблерный код main:

https://godbolt.org/z/67GGsnP74

Если мы гарантируем компилятору что в CallMe2 не передадут nullptr, то он генерирует одинаковый код (насколько это возможно в силу разного размера указателя и std::function)

CallMe1(void (*)()):
        jmp     rdi
CallMe2(std::function<void ()>):
        jmp     [QWORD PTR [rdi+24]]

void CallMe1(FuncType1 func1)
{
   func1();
}

void CallMe2(FuncType2 func2)
{
    if(!func2) {
        __builtin_unreachable();
    }
   func2();
}

https://godbolt.org/z/8j4Pd7hnr

вообще не доказывает.

Вы вообще видели тот ассемблерный вывод?

Потрясающе, аплодирую стоя!

Вот только не надо мне рассказывать что один безусловный jump может быть медленнее чем то что случилось в случае std::function. Это ж какие яйца надо иметь чтобы даже при этом говорить «не не не, деды не понимают нифига, а у нас всё модно, молодёжно, и главное б.я - супер быстро»…

Благодарю за помощь всех. В итоге сейчас это выглядит так

commandExecutor::commandExecutor(){
    AvailableCommands["Test"] = std::bind(&commandExecutor::TestFunc, this);
   
    while (true){
        cout << "Enter command: ";
        getline(cin, command);
        
        if(commandIsCorrect(command)){
            AvailableCommands[command]();
        }
        else if (command == "exit"){
            break;
        }
        else
        {
            cout << "Command \""<<command << "\" doesn't exist. Type \"Help\" to get commands" << endl;
        }
    }


}

bool commandExecutor::commandIsCorrect(string com){
    if(AvailableCommands.find(command) != AvailableCommands.end()) { return true; }
    return false;
}

void commandExecutor::TestFunc(){
    cout << "Hello this is test func\n";
}

До этого я делал без разделения на заголовочные и cpp файлы и проверку комманд делал через switch, но мне показалось это немного «грязновато»

facepalm

А что не так? Подскажи тогда как лучше исправить код?

Благодарю за помощь всех. В итоге сейчас это выглядит так

ты ипанулся что-ли? в конструкторе класса делать всю работу? конструктор КОНСТРУИРУЕТ класс и порождает обьект, который можно далее использовать.

не… ну можно и так как у тебя, плюсы все стерпят, то это противоречит и каноническим представлениям и здравому смыслу.

вообще желательно чтобы конструкторы никогда не генерили исключений и не имели сложной логики, тем более читали ввод пользователя.

Я про это уже больше 10 лет рассказываю, но они не понимают.

C++ программисты это диагноз, им хоть в глаза ссы.

Они вон, на компилятор надеются, с таким же успехом могли бы верить в магию или еще что

Исправил. Перенес всё это в main а в конструкторе оставил только добавление команд. Надеюсь я правильно понял замечание

commandExecutor::commandExecutor(){

    AvailableCommands["show date"] = std::bind(&commandExecutor::ShowDateCommand, this);

}

bool commandExecutor::commandIsCorrect(string com){
    if(AvailableCommands.find(com) != AvailableCommands.end()) { return true; }
    return false;
}

void commandExecutor::executeCommand(string com)
{
    AvailableCommands[com]();
}

void commandExecutor::ShowDateCommand()
{
    DateSetter currentDate;
    currentDate.showDate();
}

Сорян я не знал тебя эти 10 лет, но с радостью бы послушал тебя)

Что самое интересное - так типичная плюсолапша мало что тормозит и течет, так еще и выходит длиннее и неудобнее и более нечитаемо чем на Си.

Тебе уже сказали самый вменяемый вариант - делаешь if-else с проверкой строки на название команды, и руками вызываешь нужные функции.

C++ программисты это диагноз, им хоть в глаза ссы.

На секундочку - именно таковым я и являюсь….

Они вон, на компилятор надеются

А вот это - не ко мне: пока на disasm не посмотришь - никогда не знаешь что именно происходит…

Немного сарказма.

Как вот вообще на Си программы можно разрабатывать без использования стандартов, которые для C++ разработали?

В целом это не простой вопрос.
Лишний раз выскажу суждение о том, что сложность C++ не в замысловатом синтаксисе, а в том, что нужно помнить и понимать сотни «нельзя».

В целом C++ прекрасно подходит для системной разработки, а то что из него часто «уродца» делают, не его вина.

   if(AvailableCommands.find(com) != AvailableCommands.end()) { return true; }
    return false;

пиши короче

   return AvailableCommands.find(com) != AvailableCommands.end(); 

commandIsCorrect(string com){

тут передаешь строку по значению, а надо по констатной ссылке - типичная ошибка всяких там явщиков-питонистов

commandIsCorrect(const string &com){

не пиши длинных локальных имен. почитай coding guides.

Главная ошибка тут в 2 лукапах в мапу на каждую команду.