Using malloc to create triple pointer from 3d array to be passed to function which takes a triple pointer as an argument and updates its elements

The problem is simply that pointers are not arrays. Arrays are not pointers. An array may "decay" into a pointer to the first element in some cases, but that only happens once. Only on the left-most dimension when you have a multi-dimensional array.

This means that while me may pass an int[x] to a function expecting a int*, we can't pass an int[x][y] to a function expecting an int**. And so on.

Simply write the function like this instead, and keep the function body as it is:

void effect_array(int rows, int cols, int depth, int arr[rows][cols][depth])

This is a variable-length array (VLA) which can be set to any dimension of a previously known variable, meaning it has to be declared on the right-hand side of any such variable. Here the 3D array is passed by reference, not by value as it might look like (you can't pass arrays by value in C).

Now if you pass a 3D array int [x][y][z] to this function, then in the function calling expression that array will "decay" into a pointer to the first element. The first element is type int [y][z] and so a pointer to that becomes int (*)[y][z].

Now as it happens, that same "decay" happens to the declared parameter int arr[rows][cols][depth] too - it gets adjusted ("decays") into the type int (*arr)[cols][depth]. And suddenly we got two compatible types so this will work just fine.

However this requires that you have a 3D array on the caller side too. Some int*** is not an array nor can it be used to point at a 3D array, so that's a useless declaration - and even if you get it to work, it is needlessly slow for no good reason because of heap fragmentation etc. Forget that you ever saw it. More info about how to allocate arrays correctly here: Correctly allocating multi-dimensional arrays

Instead we can declare a pointer to a 2D array and when we dereference that it will be as if using a 3D array:

int x = 2;
int y = 2;
int z = 2;

int (*ptr)[y][z] = malloc( sizeof(int[x][y][z]) );

A triple-pointer (i.e. int ***ptr) is not what you need for this task. And that's what the warning tells you.

An important thing to know about C is what happens when you use an array variable. With a few exceptions (e.g. sizeof), there is an implicit conversion to "a pointer to the first array element".

Example for simple array:

int arr[N];
int n = arr[0];

// Since arr[0] holds an int, a pointer to the first element of the array,
// will have the type "pointer to int", so we can do things like:

void foo(int* a) {....}
         ^^^^

int arr[N];    
foo(arr);
int* p = arr;
^^^^

When moving to a 2D array, i.e. is an array of array of e.g. int, things get a little more complex:

int arr[M][N];
??? p = arr[0]; // What type shall p have ???

As arr is an array of array of int, arr[0] is an array of int, arr[1] is an array of int, and so on. So one could think that this would be correct:

int arr[M][N];
int p[N] = arr[0]; // THIS IS WRONG !!!

But it's wrong! The implicit conversion for arrays means that the type will be a pointer to the first element of a[0]. Since the first element of a[0] (i.e. a[0][0]) is an int, we end up with an int pointer. Like:

int arr[M][N];
int* p = arr[0]; // Correct

So let's move to the 3D case. The array of array of array of int. Note: int is just used as a simple example, it could be other types.

int arr[K][M][N];
??? p = arr[0]; // What type shall p have ???

Now things get a little complex but just apply the same way of thinking. Then we get: a[0] is an "array of array of int" (2D). When using a[0] the conversion rule says we end up with a pointer to the first element of that "array of array of int". The first element of the is "array of int" so we end up with "a pointer to an array of int". That looks like:

int arr[K][M][N];
int (*p)[N] = arr[0]; // Pointer to array of int with N elements

Now for your code... You don't want just a single of those pointers - you want an array. So you could do:

int (*ptr[2])[2];  // array of pointer to array of int
for(int i = 0; i < 2; i++)
{
    ptr[i] = arr[i];
}

oh... you also wanted dynamic allocation. So you need:

int (**ptr)[2] = malloc(2* sizeof *ptr);
for(int i = 0; i < 2; i++)
{
    ptr[i] = arr[i];
}

Then you also need to change the function so that the pointer has the correct type:

void effect_array(int (**ptr)[2], int rows, int cols, int depth)
{
    ...
}

That's it.

Example:

#include <stdio.h>
#include <stdlib.h>

#define ROWS 2
#define COLS 3
#define DEPTH 4

void effect_array(int (**ptr)[DEPTH], int rows, int cols, int depth)
{
    for(int i = 0; i < rows; i++)
    {
        for(int j = 0; j < cols; j++)
        {
            for(int k = 0; k < depth; k++)
            {
                ptr[i][j][k] *= 2;
            }
        }
    }
}


int main()
{
    int arr[ROWS][COLS][DEPTH] = {
        {
            {1, 2, 11, 22},
            {3, 4, 33, 44},
            {100, 200, 300, 400}
        },
        {
            {5,6},
            {7,8}
        }
    };
    
    int (**ptr)[DEPTH] = malloc(COLS * sizeof *ptr);
    for(int i = 0; i < COLS; i++)
    {
        ptr[i] = arr[i];
    }
    
    effect_array(ptr, ROWS, COLS, DEPTH);
    
    printf("Array after pass to effect_array2d:\n");
    printf("{");
    for(int i = 0; i < ROWS; i++)
    {
        printf("{");
        for(int j = 0; j < COLS; j++)
        {
            printf("{");
            for(int k = 0; k < DEPTH; k++)
            {
                printf("%d, ", arr[i][j][k]);
            }
            printf("},  ");
        }
        printf("},     ");
    }
    printf("}\n");

    free(ptr);

    return 0;
}

Output:

Array after pass to effect_array2d:
{{{2, 4, 22, 44, },  {6, 8, 66, 88, },  {200, 400, 600, 800, },  },     {{10, 12, 0, 0, },  {14, 16, 0, 0, },  {0, 0, 0, 0, },  },     }