Упростите функцию:

int func( int a, int b, int c, int d)
{
    if( a > b)
    {
        if( a > c)
        {
            if( a > d)
                return a;
            else
                return d;
        }
        else
        {
            if( c > d)
                return c;
            else
                return d;
        }
    }
    else
    {
        if( b > c)
        {
            if( b > d)
                return b;
            else
                return d;
        }
        else
        {
            if( c > d)
                return c;
            else
                return d;
        }
    }

    return -1;
}

Забавный пример...
Если вам интересна задача, то сначала решите её, а потом уже читайте то, что ниже ответили другие...

int func( int a, int b, int c, int d)
{
    return std::max( a, std::max(b, std::max( c, d ) ) );
}

а без std?

А чем можно пользоваться?
#define?

Чистым С\С++ без stl и прочих вкусностей, в остальном ограничений нет.

int func( int a, int b, int c, int d)
{
#define MAX(x,y) (x) > (y) ? (x) : (y)

    return MAX( a, MAX( b, MAX( c, d ) ) );
}

В принципе оптимальный вариант, а еще какие есть варианты?

вот, если не ошибся в рассуждениях )

/*
int func( int a, int b, int c, int d)
{
    if( a > b)
    {
        if( a > c)
        {
            if( a > d)
                return a;//a, если a > b && a > c && a > d
            else
                return d;//d, если a > b && a > c && a <=d
        }
        else
        {
            if( c > d)
                return c;//с, если a > b && a<=c && c > d
            else
                return d;//d, если a > b && a<=c && c <=d
        }
    }
    else
    {
        if( b > c)
        {
            if( b > d)
                return b;//b, если b > c && b > d
            else
                return d;//d, если b > c && b <=d
        }
        else
        {
            if( c > d)
                return c;//c, если b <=c && c > d
            else
                return d;//d, если b <=c && c <=d
        }
    }

    //сюда не попадём никогда
    throw;
    return -1;
}
*/

int func( int a, int b, int c, int d)
{

    //a, если a > b && a > c && a > d
    if(a>b && a>c && a>d)
    {
        return a;
    }

    //b, если b > c && b > d
    if(b>c && b>d)
    {
        return b;
    }

    //с, если a > b && a<=c && c > d
    //c, если b <=c && c > d
    if( c>d && (a>b && a<=c || b<=c))
    {
        return c
    }

    //d, если a > b && a > c && a <=d
    //d, если b > c && b <=d
    //d, если b <=c && c <=d
    return d;
}

int func( int a, int b, int c, int d)
{
    int size = 3
    int arr[3] = {b, c, d}
   
    while (size--) {
        if ( arr[size] > a) 
            a = arr[size];
    }
    return a;
}

PS: как то так

PSPS: предыдущие постеры (как и я) не учли return -1 если все элементы равны

ИЛИ

int func( int a, int b, int c, int d)
{
    if (b > a) a = b;
    if (c > a) a = c;
    if (d > a) a = d;
    return a;
}

теперь у kuzulis самый оптимальный, и читабельный вариант. Тот который без цикла.

А разве этот return когда нибудь сможет выполниться?

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

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