Создайте динамически нулевые завершенные параметры для привязки C - PullRequest
Новая
       21

Создайте динамически нулевые завершенные параметры для привязки C

0 голосов
/ 01 апреля 2019

Для моего проекта я связываю метод C ++ с функцией C. Эта функция из gstreamer и имеет переменную форму: 

GstElement *gst_element_link_many(GstElement *el1, GstElement* el2 ,[...], nullptr);

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

void linkElements(std::vector<GstElement*>& elements) {
    [...]
    gst_element_link_many(elementList... , nullptr);
}

Я думаю о пакетах параметров, но не знаю, как их реализовать.

Спасибо!

Edit: я не могу изменить функцию gstreamer, поэтому я не могу передать указатель. Gstreamer как gst_element_link (GstElement * el1, GstElement * el2); функционирует, но ведет себя по-разному, поскольку связывает элементы 2 на 2 и, таким образом, вычисляет возможности каждой пары независимо.

1 Ответ

1 голос
/ 01 апреля 2019

Пакеты параметров представляют собой конструкцию времени компиляции, а вектор - конструкцию времени выполнения. Это делает пакеты параметров несущественными для этого вопроса. Существует несколько решений, за исключением редизайна интерфейса функции C.

Первый вариант указан в Ответ М Оема на Передача всех элементов массива в функцию с переменными параметрами (…) упоминает технику одного большого переключателя: 

void linkElements(std::vector<GstElement*>& elements) {
    switch (elements.size()) {
      case 0: return gst_element_link_many(nullptr);
      case 1: return gst_element_link_many(elements[0], nullptr);
      case 2: return gst_element_link_many(elements[0], elements[1], nullptr);
      case 3: return gst_element_link_many(elements[0], elements[1], elements[2], nullptr);
      case 4: return gst_element_link_many(elements[0], elements[1], elements[2], elements[3], nullptr);
      ... and so on for how long one wants to support
      default:
         throw std::runtime_error(std::to_string(elements.size()) + " elements can't be passed (too many elements"));
}

Недостатком является то, что этот метод определяет максимальное количество параметров во время компиляции.

Второй вариант - автоматизировать оператор switch. Он использует рекурсию, поэтому он может быть менее эффективным, чем другие опции, но его очень легко расширить на большее количество параметров: 

#include <iostream>
#include <string>
#include <cstdio>
#include <vector>
#include <utility>
#include <tuple>

template <unsigned size, class Func, class Type, std::size_t... I>
void call_n(Func func, const std::vector<Type> & vec, std::index_sequence<I...>)
{
    func(vec[I]...);
}
template <unsigned size, class Func, class Type>
auto call_n(Func func, const std::vector<Type> & vec)
{
    return call_n<size>(func, vec, std::make_index_sequence<size>());
}

template <unsigned min, unsigned max, class Func, class Type>
void call_max_n(Func func, std::vector<Type> & elements)
{
    if (elements.size() == min) {
        call_n<min>(func, elements);
        return;
    }
    if constexpr(min < max)
        call_max_n<min+1, max>(func, elements);
    else
        throw std::runtime_error("Too many elements");
}

int main()
{
    std::vector<const char*> elements{"%s %s %s", "hello", "nice", "world"};
    call_max_n<1, 4>(std::printf, elements);
}

Вы можете попробовать это на wandbox . Из моих тестов, gcc может создать плоскую функцию. Может быть, в более сложных примерах он будет использовать рекурсию, но, независимо от того, сложность равна O (n), как если бы она была вызвана без какой-либо рекурсии.

(РЕДАКТИРОВАТЬ: заменен O (n 2 ) на линейный алгоритм, показанный выше).

Третий вариант дан в ответе Мэтта Джоинера на "Динамическую передачу параметров в функции с переменными числами" упоминает библиотеку C, которая может использоваться для преобразования вектора в шаблоны с переменными числами:

FFCALL - это библиотека, которая предоставляет оболочки для передачи параметров динамически с вариадическими функциями. Группа функций, которые вы интересует это avcall .

Приведенные выше ссылки устарели, и эта ссылка представляется более актуальной.

Исходя из того, как я понимаю документацию, ваш код должен выглядеть следующим образом: 

#include <avcall.h>
void linkElements(std::vector<GstElement*> & elements) {
    av_alist alist;
    av_start_void(alist, &gst_element_link_many);
    for (auto ptr: elements) {
       av_ptr(alist, GstElement*, ptr);
    }
    av_ptr(alist, GstElement*, nullptr);
    av_call(alist);
}

Я не уверен, насколько это портативно. Кажется, он работает на Linux-машинах Intel (32- и 64-разрядных) Может быть, это также может работать на Windows. Если он не работает в вашей системе, то я думаю, что не так уж сложно перенести его в вашу систему.

И Последний вариант - использовать сборку. Можно поместить данные из массива в правильные регистры и / или в стек. Это не очень сложно, и вы можете найти здесь для архитектуры Intel.

К сожалению, все гибкие решения не являются чисто C ++ и требуют некоторого добавления (либо из библиотеки, либо из кода сборки).

РЕДАКТИРОВАТЬ : Я добавил одно из решений для github , и я собираюсь использовать все вышеперечисленные решения.

...