Re: char *(*(**foo[][8])())[]; - за сколько распарсите? - C/C++

Здравствуйте, 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];

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

Здравствуйте, 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

Здравствуйте, 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

Здравствуйте, 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>"Всемогущий" GPT не осилил:
S>Вообще возможно ли это как-то инициализировать и вызвать?

Да что ж вы такие беспомощные

Ну ладно Chat GPT, ей простительно — она маленькая девочка. Но ты-то — лоб здоровый, которому выше уже все разжевали — что не осилил опять?

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

#include <iostream>

const char* arr1[] = {"foo", "bar", "baz", nullptr}; // пример массива строк
const char* arr2[] = {"one", "two", "three", "four", nullptr}; // ещё один массив строк

// определение функций, возвращающих указатели на массивы строк
const char* (*func1())[] { return &arr1; }
const char* (*func2())[] { return &arr2; }

// определение указателей на функции
const char* (*(*fptr1)())[] = &func1;
const char* (*(*fptr2)())[] = &func2;


int main()
{
    // Инициализация foo - только не "с помощью двух элементов", а так, как это было в оригинальном варианте - массив произвольного размера
    const char*(*(**foo[][8])())[] = {
        { &fptr1 }, // первый элемент указывает на функцию, возвращающую arr1
        { &fptr2 }, // второй элемент указывает на функцию, возвращающую arr2
        { &fptr1, &fptr2 }, // третий элемент указывает на две функции
        { &fptr1, &fptr2, &fptr1, &fptr2, &fptr1, &fptr2, &fptr1, &fptr2 }, // четвертый элемент тоже на что-то указывает
        { }, // пятый элемент - пустой (содержит восемь nullptr)
    };
    
    // Aнализ и использование foo

    using String = const char*;
    using ArrayOfString = String[];
    using Function = ArrayOfString*();
    
    for (Function** (&afpp)[8]  : foo)
    {
        std::cout << "{ ";
        for (Function** fpp : afpp)
        {
            if (fpp)
            {
                if (Function* fp = *fpp)
                {
                    if (ArrayOfString* asptr = fp())
                    {
                        std::cout << "[ ";
                        for (const String* s = *asptr; *s; ++s)
                        {
                            std::cout << *s << ' ';
                        }
                        std::cout << "] ";
                    }
                }
            }
        }
        std::cout << "}" << std::endl;
    }
}

g++ -std=c++20 -O2 -Wall -pedantic -pthread main.cpp && ./a.out
{ [ foo bar baz ] }
{ [ one two three four ] }
{ [ foo bar baz ] [ one two three four ] }
{ [ foo bar baz ] [ one two three four ] [ foo bar baz ] [ one two three four ] [ foo bar baz ] [ one two three four ] [ foo bar baz ] [ one two three four ] }
{ }

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

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

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

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

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

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

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

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

R>

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

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

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

... << RSDN@Home 1.3.110 alpha 5 rev. 62>>

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

И как это дебажить?

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

R>Баян. http://rsdn.org/forum/cpp/4376609.1
R>К тому же еще и конструкция не валидная.

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

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

Здравствуйте, 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>Вставил ваш пример и чего-то не работает: 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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Кстати, это тоже интересно в качестве ребуса то.

"Всемогущий" GPT не осилил:

char* (*(**foo[][8])())[]; // объявление переменной foo

char* arr1[] = {"foo", "bar", "baz"}; // пример массива строк
char* arr2[] = {"one", "two", "three", "four"}; // ещё один массив строк

// определение функции, возвращающей указатель на массив строк
char** func() {
    return arr1;
}

// инициализация foo с помощью двух элементов
char* (*(*foo[2][8])())[] = {
    {&func}, // первый элемент указывает на функцию, возвращающую arr1
    {NULL}   // второй элемент - нулевой указатель
};

// изменение второго элемента foo, чтобы он указывал на arr2
foo[1][0] = (char* (*(**)())[]) &arr2;

// использование foo
char** res = (*foo[0][0])(); // вызов функции, возвращающей arr1
printf("%s\n", res[1]); // печать "bar"
printf("%s\n", (*foo[1][0])[2]); // печать "three"

Вообще возможно ли это как-то инициализировать и вызвать?

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

Помню в одном проекте у нас супер-умный чувак был, математик нехилый и вообще вундеркинд.
Так вот, у него была шиза — он всё… всё!!! ВСЁ писал через макросы.
То есть его программа выглядела так

int main()
{
MYSUPERMACROS1;
MYSUPERMARCOS2;
MYSUPERMWCROS3;
}

И эти макросы — это не просто однострочные коды — это охренеть какая сложная взаимосвязанная структура вложенных и зависимых других макросов

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

Твой код можно оформить гораздо читаемее. И нефиг извращаться.

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

Н>Помню в одном проекте у нас супер-умный чувак был, математик нехилый и вообще вундеркинд.
Н>Так вот, у него была шиза — он всё… всё!!! ВСЁ писал через макросы.
Н>То есть его программа выглядела так

Н>int main()
Н>{
Н> MYSUPERMACROS1;
Н> MYSUPERMARCOS2;
Н> MYSUPERMWCROS3;
Н>}

Н>И эти макросы — это не просто однострочные коды — это охренеть какая сложная взаимосвязанная структура вложенных и зависимых других макросов

Н>Не знай нафига он так делал. Чтоб свою незаменимость подчеркнуть и чтоб в его коде хрен кто после не разобрался?

О, я тоже так писал когда-то

Лет эдак 25 назад. Моя первая версия алгоритма А-звездочка так была написана. Почему на макросах? Ну чтоб не тратить драгоценные такты процессора на выполнение вызовов функций. Было такое мнение, что в потерях в производительности виноваты вызовы функций

А еще я фукнцию извлечения квадратного корня писал на ассемблере, примерно в тот же период

Я думаю, многие через это проходили. А некоторые так и застряли в том состоянии, судя по тому, что они тут пишут

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

Н>И как это дебажить?

А никак

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

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

R>Ну ладно Chat GPT, ей простительно — она маленькая девочка. Но ты-то — лоб здоровый, которому выше уже все разжевали — что не осилил опять?

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

В С++ много неочевидных моментов, связанных с декларированием сложных вещей. К примеру, пока не увидел какая сигнатура у функции, возвращающей указатель на другую функцию — никогда бы сам не догадался.

Этот пример многое раскрывает.

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

Н>int main()
Н>{
Н> MYSUPERMACROS1;
Н> MYSUPERMARCOS2;
Н> MYSUPERMWCROS3;
Н>}

Н>И эти макросы — это не просто однострочные коды — это охренеть какая сложная взаимосвязанная структура вложенных и зависимых других макросов

Тут вопрос не чтобы так писать. А чтобы если кто-то уже написал, но хотя бы какие-то шансы были разораться в написанном.

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

Если бы ты воспользовался этим подходом, то очень быстро у тебя все разложилось бы по полочкам. Но ты, как обычно, решил, что написанное не стоит твоего внимания. Да?

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

S>В С++ много неочевидных моментов, связанных с декларированием сложных вещей. К примеру, пока не увидел какая сигнатура у функции, возвращающей указатель на другую функцию — никогда бы сам не догадался.

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

Конструирование сложного объявления проще всего выполнять последовательно, добавляя новые синтаксические элементы непосредственно слева или справа от имени. Например, имеем изначально простое объявление:

Функция, принимающая строку и возвращающая число:

int foo(const char*);

Указатель на функцию, принимающую строку и возвращающую число (используем дополнительные круглые скобки):

int (*foo)(const char*);

Массив указателей на функции принимающие строку, и возвращающие число (добавляем квадратные скобки с размерностью массива сразу справа от имени):

int (*foo[42])(const char*);

Указатель на массив указателей на функции принимающие строку, и возвращающие число (опять используем дополнительные круглые скобки)

int (*(*foo)[42])(const char*);

Функция, принимающая double, возвращающая указатель на массив указателей на функции принимающие строку, и возвращающие число
(просто добавляем справа от имени декларации список формальных параметров в круглых скобках):

int (*(*foo(double))[42])(const char*);

Указатель на функцию, принимающую double, возвращающую указатель на массив указателей на функции принимающие строку, и возвращающие число

int (*(*(*foo)(double))[42])(const char*);

Анализ выполняется в обратном порядке, начиная от имени объявления.

Сложнее всего, когда имя в объявлении опущено и найти его не всегда просто:

using FooPtr = int (*(*(*)(double))[42])(const char*);

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

Но на практике таких многоэтажных объявлений лучше вообще избегать, используя using или typedef.

	От:	Shmj
	Дата:	20.04.23 08:16
	Оценка:	-6

От:	Pzz	https://github.com/alexpevzner
Дата:	20.04.23 11:11
Оценка:	+7

	От:	rg45
	Дата:	20.04.23 09:09
	Оценка:	23 (3) +3

От:	reversecode	google
Дата:	04.05.23 13:28
Оценка:	+4

	От:	rg45
	Дата:	20.04.23 21:39
	Оценка:	8 (2)

	От:	Кодт
	Дата:	05.05.23 09:31
	Оценка:	7 (1)

	От:	wander
	Дата:	28.04.23 17:45
	Оценка:	+1

	От:	CreatorCray
	Дата:	06.05.23 00:12
	Оценка:	-1

	От:	Нomunculus
	Дата:	06.05.23 08:49
	Оценка: