我将对myfunction2中的参数使用const关键字，以便

情况1：编译时，如果参数也是const结构，则调用方使用的结构上的任何更改肯定会生成error;
用例2：如果调用方的参数不是常量，则至少为warning。
案例1：

foo.h

#ifndef FOO_H
#define FOO_H

typedef struct fooStruct
{
  int a;
  int b;
  int c;

}t_fooStruct;

void cpy_foo(const t_fooStruct ** structToCpy);

#endif

foo.c

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

t_fooStruct myData = {0,1,2};

void cpy_foo(const t_fooStruct ** structToCpy){
  *structToCpy = &myData;
}

main.c

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

int main(){

  const t_fooStruct * mainData;

  cpy_foo(&mainData);
  printf("After cpy print %d %d %d\n", mainData->a, mainData->b, mainData->c);

  mainData->a = 10;
  mainData->b = 20;
  mainData->c = 30;
  printf("After changes print %d %d %d\n\n", mainData->a, mainData->b, mainData->c);

  return 0;
}

在编译时，这给出：

main.c: In function 'main':
main.c:12:15: error: assignment of member 'a' in read-only object
   12 |   mainData->a = 10;
      |               ^
main.c:13:15: error: assignment of member 'b' in read-only object
   13 |   mainData->b = 20;
      |               ^
main.c:14:15: error: assignment of member 'c' in read-only object
   14 |   mainData->c = 30;
      |

案例2：

如果这个结构基本上不是一个常量：main. c（不带常量的版本）

int main(){

  t_fooStruct * mainData;

  cpy_foo(&mainData);
[...]

编译时，此输出：

9 |   cpy_foo(&mainData);
      |           ^~~~~~~~~
      |           |
      |           t_fooStruct ** {aka struct fooStruct **}
In file included from main.c:3:
foo.h:12:35: note: expected 'const t_fooStruct **' {aka 'const struct fooStruct **'} but argument is of type 't_fooStruct **' {aka 'struct fooStruct **'}
   12 | void cpy_foo(const t_fooStruct ** structToCpy);