您好，有个问题NC65网报（我们叫共享）的问题请教一下

您好，有个问题NC65网报（我们叫共享）的问题请教一下
我弄了个参照，在重量端没什么问题，也都配置好了显示，过滤什么的都没问题，轻量端却报错显示参照不存在，请问有可能是什么原因？

检查轻量端的单据模板是否配置该参照了；

这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7476905
这篇博客你也可以参考下：for循环里调NC部门插入的方法，一个数据错误就全部回滚
除此之外, 这篇博客: 【C语言】数据结构预备知识，指针，数组，结构体，动态内存分配与释放中的 2.5 动态内存分配和释放 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:
（使用malloc分配的就是动态内存，不使用的就是静态内存。动态分配的内存一定要手动释放，否则造成内存泄露。）
（java中A aa = new A();其实就是 A *p = (A *)malloc(sizeof(A))）
动态内存分配和释放：
动态构造一维数组
假设动态构造一个int型数组
int *p = (int *)malloc(int len);
1、 malloc只有一个int型的形参，表示要求系统分配的字节数
2、 malloc函数的功能是请求系统len个字节的内存空间，如果请求分配成功，则返回第一个字节的地址，如果分配不成功，则返回NULL
3、 malloc函数能且只能返回第一个字节的地址，所以我们需要把这个无任何实际意义的第一个字节的地址（俗称干地址）转化为一个有实际意义的地址，因此malloc前面必须加（数据类型 *）,表示把这个无实际意义的第一个字节的地址转化为相应类型的地址。如：
int *p = (int *)malloc(50);
表示将系统分配好的50个字节的第一个字节的地址转化为int *型的地址，更准确的说是把第一个字节的地址转化为四个字节的地址，这样p就指向了第一个的四个字节，p+1就指向了第2个的四个字节，p+i就指向了第i+1个的4个字节。p[0]就是第一个元素， p[i]就是第i+1个元素
double *p = (double *)malloc(80);
表示将系统分配好的80个字节的第一个字节的地址转化为double *型的地址，更准确的说是把第一个字节的地址转化为8个字节的地址，这样p就指向了第一个的8个字节，p+1就指向了第2个的8个字节，p+i就指向了第i+1个的8个字节。p[0]就是第一个元素， p[i]就是第i+1个元素
free（p）
释放p所指向的内存，而不是释放p本身所占用的内存
```
# include <stdio.h>
# include <malloc.h>

int main(void)
{
	int a[5] = {4, 10, 2, 8, 6};//静态分配内存

//用指针动态分配内存，模拟数组	
	int len;
	printf("请输入你需要分配的数组的长度: len = ");
	scanf("%d", &len);
	int * pArr = (int *)malloc(sizeof(int) * len);
//sizeof(int)是整型的字节数，若len=5，则(sizeof(int) * len)=20，20表示malloc函数请求操作系统为程序分配20字节的空间。(int *)是强制转换，无论一个变量占几个字节，malloc函数只能返回第一个字节地址，这个地址是无意义地址（干地址），所以前面需要强制转换，告诉编译器第一个地址是什么类型（int or double……）的地址
//	*pArr = 4;  //类似于 a[0] = 4; 
//	pArr[1] = 10; //类似于a[1] = 10;
//	printf("%d %d\n", *pArr, pArr[1]);

	//我们可以把pArr当做一个普通数组来使用
	for (int i=0; i<len; ++i)
		scanf("%d", &pArr[i]);

	for (i=0; i<len; ++i)
		printf("%d\n", *(pArr+i));

	
	free(pArr);  //把pArr所代表的动态分配的20个字节的内存释放

	return 0;
}
```
跨函数使用内存:
8、下列程序中，能够通过调用函数fun，使main函数中的指针变量p指向一个合法的整型单元的是
```
A) main()
  {  int *p;
     fun(p);
     … 
  } 
  int fun(int *p)
  { int s; 
    p=&s;
  }
B) main()
   { int *p;
     fun(&p);
     …
   }
  int fun(int **q)
  {  int s;
     *q=&s;
  }
C) #include <stdlib.h>
   main()
   {  int *p;  //p变量地址发送给q，则*q=q
      fun(&p);
      …
   }
   int fun(int **q)
   {  *q=(int *)malloc(4);  //p指向4个字节，函数执行完后，这4个字节没有消失，因为内存没释放
   }
D) 
   #include <stdlib.h>
   main() 
  {  int  *p;
     fun(p);
     …
   }
   int fun(int *p)
   {  p=(int *)malloc(sizeof(int));
   }
```
注释：这个题很有意思。考查了：
1. 指针的指针的使用 2) 动态内存分配与自动变量的内存分配。
  动态分配的内存必须调用free()函数才能释放，而自动变量一旦跳出它的代码作用范围，就会由编译器自动释放掉。
  让我们先看：
  A) 选项无论fun()中p的值如何变化，都不会影响到主函数中p的值，因为它是值传递
  B) 选项倒是把p的地址&p传递给了fun()函数，但遗憾的是，由于s是个自动变量，当推出fun()函数后，s变量所占内存单元会被会被释放掉，此时主函数中的p还是没法指向一个合法的int型单元
  C) 选项fun()的形参 int **p;表明p是个指向指针变量的指针变量，即是个指针的指针。而主函数中的 int *p; 表明p只是个指针变量，但&p则指向了p，&p也是个指向指针变量p的指针变量，实参和形参类型一致。 fun()的功能是使实参p指向了一个int型变量，又由于该int型变量是由malloc()动态分配的，所以推出fun()函数并不会影响实参p的指向，故C是对
  D) 选项犯了和A同样的错误。真想不到二C还会考到这个知识，哈哈!
```
# include <stdio.h>
# include <malloc.h>

struct Student
{
	int sid;
	int age;
};

struct Student * CreateStudent(void);
void ShowStudent(struct Student *);

int main(void)
{
	struct Student * ps;

	ps = CreateStudent();
	ShowStudent(ps);

	return 0;
}

void ShowStudent(struct Student * pst)
{
	printf("%d %d\n", pst->sid, pst->age);
}

struct Student * CreateStudent(void)
{
	struct Student * p = (struct Student *)malloc(sizeof(struct Student));
	p->sid = 99;
	p->age = 88;
	return p;
}
//输出99 88
```