Вот интересно у кого глаз наметан и уже много лет с этим возитесь — сколько времени у вас уйдет на то, чтобы распарсить эту абракадабру и понять как, допустим, ее проинициализировать?

Скажем, проинициализировать так — в корне char с значением 'a', а далее везде массивы с 1 элементом.

Здравствуйте, Shmj, Вы писали:

S>Вот интересно у кого глаз наметан и уже много лет с этим возитесь — сколько времени у вас уйдет на то, чтобы распарсить эту абракадабру и понять как, допустим, ее проинициализировать?

Баян. http://rsdn.org/forum/cpp/4376609.1

Автор: rg45
Дата: 11.08.11

Здравствуйте, rg45, Вы писали:

R>Баян. http://rsdn.org/forum/cpp/4376609.1

Автор: rg45
Дата: 11.08.11

R>К тому же еще и конструкция не валидная.

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

Вставил ваш пример и чего-то не работает: https://ideone.com/k9ZXbI

Здравствуйте, Shmj, Вы писали:

S>Можно попросить вас обновить код, а то не доступно по вашей ссылке.

Пожалуйста: http://coliru.stacked-crooked.com/a/07a5c77c99110987

char*(*(**[][8])())[]

array of unspecified size of array [8] of pointer to pointer to function without parameters returning pointer to array of unspecified size of pointer to char

P.S. Если захочется с этим поиграться, то, возможно тебе придется расширять набор специализаций. Думаю, это будет не очень сложно — по образу и подобию.

P.P.S. Ну и что хочется заметить, что сложность объявлений в C/C++ не является открытием и прямо вот в таком виде в промышленном коде никто такие конструкции не употребляет. Благо есть алиасы типов с помощью которых коду можно придать удобочитаемый вид.

Вот такое нехитрое разложение:

    using A = char*[];
    using F = A*();
    using foo = F**[][8];

Здравствуйте, Shmj, Вы писали:

S>char *(*(**foo[][8])())[]; — за сколько распарсите?

Ты если решил-таки заняться самообразованием (что отрадно), то я бы тебе рекомендовал начать вот с этой замечательной книженции, которую я рекомендовал и рекомендую всем, кто не читал:

https://libcat.ru/knigi/kompyutery-i-internet/programmirovanie/228582-gerb-satter-standarty-programmirovaniya-na-s-101-pravilo-i-rekomendaciya.html

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

P.S. Книжечка совсем небольшая и прекрасно структурирована. Можно читать все подряд, а можно выборочно — за что глаз зацепится.

Здравствуйте, Shmj, Вы писали:

S>Вот интересно у кого глаз наметан и уже много лет с этим возитесь — сколько времени у вас уйдет на то, чтобы распарсить эту абракадабру и понять как, допустим, ее проинициализировать?

Если б мне такое на кодревью вывалили, ну, оно не прошло бы ревью.

Здравствуйте, Shmj, Вы писали:

S>Вставил ваш пример и чего-то не работает: https://ideone.com/k9ZXbI

Только сейчас открыл ссылку — это трындец, конечно.

А ты комментарии читал вокруг или "вставил" первый фрагмент, который попался под руку?

И что, даже предположений не возникает, почему не работает?

Здравствуйте, rg45, Вы писали:

R>Пожалуйста: http://coliru.stacked-crooked.com/a/07a5c77c99110987

R>char*(*(**[][8])())[]
R>

R>array of unspecified size of array [8] of pointer to pointer to function without parameters returning pointer to array of unspecified size of pointer to char

R>P.S. Если захочется с этим поиграться, то, возможно тебе придется расширять набор специализаций. Думаю, это будет не очень сложно — по образу и подобию.
И как по подобию будет для "void (X::*)()" http://coliru.stacked-crooked.com/a/97f7fe57e86d98a4

Здравствуйте, kov_serg, Вы писали:

_>И как по подобию будет для "void (X::*)()" http://coliru.stacked-crooked.com/a/97f7fe57e86d98a4

Элементарно, Ватсон:

http://coliru.stacked-crooked.com/a/03d0ed23b6d4ba92

#include <iostream>
#include <string>

template <typename T, typename=void> struct TypeFormatter { std::string operator()() const { return "unknown type"; } };
template <typename T> struct TypeFormatter<const T> { std::string operator()() const { return "const " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T*> { std::string operator()() const { return "pointer to " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T&> { std::string operator()() const { return "lvalue refrence to " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T[]> { std::string operator()() const { return "array of unspecified size of " + TypeFormatter<T>()(); } };
template <typename T, size_t N> struct TypeFormatter<T[N]> { std::string operator()() const { return "array [" + std::to_string(N) + "] of " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T()> { std::string operator()() const { return "function without parameters returning " + TypeFormatter<T>()(); } };
template <> struct TypeFormatter<void> { std::string operator()() const { return "void"; } };
template <typename T, typename C> struct TypeFormatter<T C::*> { std::string operator()() const {return "pointer to member of '" + TypeFormatter<C>()() + "' of type: " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T, std::void_t<typename T::TypeFormatter>> : T::TypeFormatter{};

int main()
{
    struct X {
        struct TypeFormatter { std::string operator()() const { return "main::struct X"; }; };
    };
    std::cout << TypeFormatter< void (X::*)() >()() << std::endl;
}

pointer to member of 'main::struct X' of type: function without parameters returning void

Здравствуйте, rg45, Вы писали:

R>Элементарно, Ватсон:

R>http://coliru.stacked-crooked.com/a/03d0ed23b6d4ba92

А лямбды можно впихать? http://coliru.stacked-crooked.com/a/895450c6e1f7529f

Здравствуйте, kov_serg, Вы писали:

_>http://coliru.stacked-crooked.com/a/895450c6e1f7529f

ИМХО, ты напрасно завел отдельную специализацию для указателей на функции-члены. И члены-данные, и члены-функции можно обработать общей специализацией указателя на член. Разница только в том, что в одном случае будет тип-объект, а в другом тип-функция. И первое и второе потом распарсится соответствующими специализациями. Подход с общей специализацией формирует более правильное представление о структуре синтаксиса (это ведь учебное упражнение). Да и писанины меньше — и свободные функции, и функции-члены сводятся к одному общему анализатору.

_>А лямбды можно впихать?

Можно, но с ограничением: без auto в параметрах. Тип возвращаемого значения может быть auto. Можно одним движением охватить и ляибды, и std::function, и пользовательские функционалы.

http://coliru.stacked-crooked.com/a/bf3ecafeeefc3b9c

#include <iostream>
#include <string>
#include <functional>

template <typename T, typename=void> struct TypeFormatter { std::string operator()() const { return "unknown type"; } };

template <typename...> struct FormatParamList;
template <> struct FormatParamList<> { std::string operator()() const {return {};} };
template <typename A, typename...X> struct FormatParamList<A, X...> { std::string operator()() const { return (TypeFormatter<A>{}() + ... + (", " + TypeFormatter<X>{}()));} };

template <typename> struct FunObjFormatter;
template <typename T, typename C, typename...A> struct FunObjFormatter<T(C::*)(A...)> { std::string operator()() const { return "functional object (" + FormatParamList<A...>{}() + ") returning " + TypeFormatter<T>{}();} };
template <typename T, typename C, typename...A> struct FunObjFormatter<T(C::*)(A...) const> { std::string operator()() const { return "immutable " + FunObjFormatter<T(C::*)(A...)>{}();} };

template <> struct TypeFormatter<void> { std::string operator()() const { return "void"; } };
template <> struct TypeFormatter<int> { std::string operator()() const { return "int"; } };
template <> struct TypeFormatter<char> { std::string operator()() const { return "char"; } };
template <> struct TypeFormatter<double> { std::string operator()() const { return "double"; } };
template <> struct TypeFormatter<std::string> { std::string operator()() const { return "std::string"; } };
template <typename T> struct TypeFormatter<const T> { std::string operator()() const { return "const " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T*> { std::string operator()() const { return "pointer to " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T&> { std::string operator()() const { return "lvalue refrence to " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T[]> { std::string operator()() const { return "array of unspecified size of " + TypeFormatter<T>()(); } };
template <typename T, size_t N> struct TypeFormatter<T[N]> { std::string operator()() const { return "array [" + std::to_string(N) + "] of " + TypeFormatter<T>()(); } };
template <typename T, typename C> struct TypeFormatter<T C::*> { std::string operator()() const {return "pointer to member of '" + TypeFormatter<C>()() + "' of type: " + TypeFormatter<T>()(); } };
template <typename T> struct TypeFormatter<T, std::void_t<typename T::TypeFormatter>> : T::TypeFormatter{};
template <typename T, typename...A> struct TypeFormatter<T(A...)> { std::string operator()() const {return "function (" + FormatParamList<A...>{}() + ") returning " + TypeFormatter<T>{}();} };
template <typename T, typename...A> struct TypeFormatter<T(A...) const> { std::string operator()() const {return "immutable " + TypeFormatter<T(A...)>{}();} };
template <typename T> struct TypeFormatter<T, std::void_t<decltype(&T::operator())>> : FunObjFormatter<decltype(&T::operator())> {};

namespace NS {
    struct A { };
};
//using NS::A;
//typedef NS::A A;
struct A:NS::A {};

template <> struct TypeFormatter<A> { std::string operator()() const {return "struct A";} };

int main()
{
    std::cout << "01. " << TypeFormatter< char*(*(**[][8])())[] >()() << std::endl;
    std::cout << "02. " << TypeFormatter< int (*)(char,char*(*(**[][8])())[],int) >()() << std::endl;
    std::cout << "03. " << TypeFormatter< int (*)() >()() << std::endl;
    std::cout << "04. " << TypeFormatter< int A::* >()() << std::endl;

    std::cout << "05. " << TypeFormatter<int(const char&, double&)>()() << std::endl;
    std::cout << "06. " << TypeFormatter<int(const char&, double&) const>()() << std::endl;
    std::cout << "07. " << TypeFormatter<int()>()() << std::endl;
    std::cout << "08. " << TypeFormatter<int() const>()() << std::endl;

    auto l1 = []{};
    auto l2 = [](int) { return 3.14; };
    auto l3 = [](int) mutable { return 3.14; };
    auto l4 = [](int, const std::string&, const char*, double) mutable { return 3.14; };

    std::cout << "09. " << TypeFormatter<decltype(l1)>()() << std::endl;
    std::cout << "10. " << TypeFormatter<decltype(l2)>()() << std::endl;
    std::cout << "11. " << TypeFormatter<decltype(l3)>()() << std::endl;
    std::cout << "12. " << TypeFormatter<decltype(l4)>()() << std::endl;

    std::function<double(int, const std::string&, double, const char*)> f1 = std::bind(l3, std::placeholders::_1);

    std::cout << "13. " << TypeFormatter<decltype(f1)>()() << std::endl;
}

01. array of unspecified size of array [8] of pointer to pointer to function () returning pointer to array of unspecified size of pointer to char
02. pointer to function (char, pointer to array [8] of pointer to pointer to function () returning pointer to array of unspecified size of pointer to char, int) returning int
03. pointer to function () returning int
04. pointer to member of 'struct A' of type: int
05. function (lvalue refrence to const char, lvalue refrence to double) returning int
06. immutable function (lvalue refrence to const char, lvalue refrence to double) returning int
07. function () returning int
08. immutable function () returning int
09. immutable functional object () returning void
10. immutable functional object (int) returning double
11. functional object (int) returning double
12. functional object (int, lvalue refrence to const std::string, pointer to const char, double) returning double
13. immutable functional object (int, lvalue refrence to const std::string, double, pointer to const char) returning double

Здравствуйте, rg45, Вы писали:

R>И что, даже предположений не возникает, почему не работает?

И как всегда нет от ТС ответа.
Никогда диалога не получается.

Здравствуйте, wander, Вы писали:

R>>И что, даже предположений не возникает, почему не работает?

W>И как всегда нет от ТС ответа.
W>Никогда диалога не получается.

Не все сразу — позже вернусь к этому. Пока нет привычной мне IDE под рукой.

Здравствуйте, rg45, Вы писали:

S>>Вставил ваш пример и чего-то не работает: https://ideone.com/k9ZXbI

R>Только сейчас открыл ссылку — это трындец, конечно.
R>А ты комментарии читал вокруг или "вставил" первый фрагмент, который попался под руку?
R>И что, даже предположений не возникает, почему не работает?

Тогда не глянул, сейчас посмотрел — read_type же требует передачи 1 аргумента. Но не понятно как вам удалось вызывать ее без аргументов.

std::cout << read_type<int(*(&)[42])()>() << std::endl;

Вроде ж ни один компилятор такое не пропустит.

ваша проф не пригодность доказана
и собеседование не потребовалось

Здравствуйте, reversecode, Вы писали:

R>
R>ваша проф не пригодность доказана
R>и собеседование не потребовалось

Вы о свой проф. пригодности подумайте

Автор: reversecode
Дата: 04.05.23

лучше. Я бы не брал в команду человека, который хейтит, унижает. Вы, может быть, пока выгодно — не раскрываете свою сущность. Но как только что — ожидай подвоха.

Я никогда не унижаю людей — даже если они имеют некие проблемы с интеллектом или что-то сложно им дается. Каждому свое. Просто либо пройду мимо либо покажу верное решение без перехода на личности.

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

я бы таких пиявок паразитов вообще выгонял ото всюду

Здравствуйте, reversecode, Вы писали:

R>то есть то что вы пиявка паразит вы за собой не замечаете ?
R>и то как вас все откровенное не любят как минимум в теме С++ тоже ?
R>я бы таких пиявок паразитов вообще выгонял ото всюду

Что значит паразит? Форум и создан для обсуждения вопросов. Простые вопросы обсуждают на этом же форуме.

Нет возможности ответить — я вас за язык не тяну, можете не отвечать.

Здравствуйте, Shmj, Вы писали:

S>Вот интересно у кого глаз наметан и уже много лет с этим возитесь — сколько времени у вас уйдет на то, чтобы распарсить эту абракадабру и понять как, допустим, ее проинициализировать?

У балтийцев на контру особый нюх: из нагана в лоб контре — ТЮХ!

Абсолютно в любом языке есть способы писать write only код.
И в любом коллективе есть методы так не делать.
Начиная от организационных: пулреквест не пройдёт ревью, коллеги в курилке набьют морду, подставьте ваши варианты.
И кончая литературными: переписать код так, чтобы он стал читаемым.

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

char *(*(**foo[][8])())[];

typedef char *ptr_to_char;
ptr_to_char(*(**foo[][8])())[];

typedef ptr_to_char array_of_ptr_to_char[];
array_of_ptr_to_char *(**foo[][8])();

typedef array_of_ptr_to_char *ptr_to_array_of_ptr_to_char;
ptr_to_array_of_ptr_to_char(**foo[][8])();

typedef ptr_to_array_of_ptr_to_char(function_takes_nothing_returns_ptr_to_array_of_ptr_to_char)();
function_takes_nothing_returns_ptr_to_array_of_ptr_to_char **foo[][8];

typedef function_takes_nothing_returns_ptr_to_array_of_ptr_to_char *ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char;
ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char *foo[][8];

typedef ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char *ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char;
ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char foo[][8];

typedef ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char array_of_8_ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char[8];
array_of_8_ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char foo[];

typedef array_of_8_ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char array_of_array_of_8_ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char[];
array_of_array_of_8_ptr_to_ptr_to_function_takes_nothing_returns_ptr_to_array_of_ptr_to_char foo;

S>Скажем, проинициализировать так — в корне char с значением 'a', а далее везде массивы с 1 элементом.

Нафиг.

Здравствуйте, Shmj, Вы писали:

S>Вот интересно у кого глаз наметан и уже много лет с этим возитесь — сколько времени у вас уйдет на то, чтобы распарсить эту абракадабру и понять как, допустим, ее проинициализировать?

За такое в production code полагается тапком и нахрен на мороз из профессии.