从JM8.6解码器中学习多级指针的应用

最新推荐文章于 2021-05-19 17:27:06 发布
最新推荐文章于 2021-05-19 17:27:06 发布
阅读量8k 收藏 4
点赞数 1
分类专栏： S1: C/C++ s6: 视频研究
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/stpeace/article/details/8443583
版权

        在JM8.6中多次出现多级指针，之前的博文已经有介绍多级指针和多级数组的关系. 下面继续来看看多级指针, 以便进一步熟悉.(说明：下面的程序都没有考虑堆内存的释放)

       先来简单预热一下：

#include <stdio.h>

typedef unsigned char byte;

int main()
{
	byte a = 0;
	printf("%d\n", a);

	byte *p = &a;
	*p = 100;
	printf("%d\n", a);

	return 0;
}
#include <stdio.h>

typedef unsigned char byte;

void setData(byte *p)
{
    *p = 100;
}

int main()
{
	byte a = 0;
	printf("%d\n", a);

	setData(&a);
	printf("%d\n", a);

	return 0;
}
#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

byte* getMemory()
{
    byte *p = (byte *)calloc(1, sizeof(byte));
	
	return p; // 返回指向堆空间的栈指针
	          // 如果返回指向栈空间的栈指针，则没用
}

int main()
{
	byte *p = NULL;
	p = getMemory();
	*p = 100;
	printf("%d\n", *p);

	return 0;
}
#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

void getMemory(byte* &p)// 在C++中可以用引用
{
    p = (byte *)calloc(1, sizeof(byte));
}

int main()
{
	byte *p = NULL;
	getMemory(p);
	*p = 100;
	printf("%d\n", *p);

	return 0;
}                      

// 下面这个程序有错误

#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

// 该函数不能实现相应的功能
void getMemory(byte *p)
{
    p = (byte *)calloc(1, sizeof(byte));
}

int main()
{
	byte *p = NULL;
	getMemory(p);
	*p = 100;
	printf("%d\n", *p);

	return 0;
}

       上面这个有错误的程序应该改为：

#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

void getMemory(byte **p)
{
    *p = (byte *)calloc(1, sizeof(byte));
}

int main()
{
	byte *p = NULL;
	getMemory(&p);
	*p = 100;
	printf("%d\n", *p);

	return 0;
}

      上面预热之后，对指针的概念算是基本懂了 . 由此可以得出这样的结论：如果要修改主调函数中的整形变量a, 那么在被调函数中就要用指向整形变量的指针来指向a；如果要修改主调函数中的整形指针变量p，那么在被调函数中，就应该用指向整形指针的指针来指向p.

 

        下面看一下稍微复杂的情况：

#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

void getMemory(byte **p, int n)
{
    *p = (byte*)calloc(n, sizeof(byte));
}

int main()
{
	int n = 3;
	byte *p = NULL; // 一维指针

	getMemory(&p, n);

	int i;
	for(i = 0; i < n; i++)
	{
		p[i] = i + 1; // 在形式上是一维数组
	}

	for(i = 0; i < n; i++)
	{
		printf("%d\t", p[i]);	
	}

	printf("\n");

	return 0;
}

       结果为：

1       2       3

 

       下面看看二维数组的动态分配：

// 搞懂这个程序. 真的很重要.

#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

/* 
    下面假设：rows为3, columns为4.
   
    被调函数中的*array2D实际上就是指向指针的指针，
    *array2D实际上就指向了3段连续的内存.

    (*array2D) + 0 指向了第1段连续的内存；
	(*array2D) + 1 指向了第2段连续的内存；
	(*array2D) + 2 指向了第3段连续的内存；
	每一段连续的内存相当于一个byte* 形式的指针.

   
    get_mem2D中第二行申请的空间大小为：3 * 4
    地址是连续的，本质上是连续的存储单元,
    可以把每一段内存理解为矩阵的一行, 如此一来，便有：
	(*array2D)[0]指向了矩阵的第1行；
	(*array2D)[1]指向了矩阵的第2行；
	(*array2D)[2]指向了矩阵的第3行；
    而每一行又有4个byte型的元素.

	
    注意：被掉函数中的*array2D实际上就是主调函数中的array2D
*/ 
void get_mem2D(byte ***array2D, int rows, int columns)
{
    *array2D = (byte**)calloc(rows, sizeof(byte*));

    (*array2D)[0] = (byte*)calloc(columns * rows, sizeof(byte));
	int i;
    for(i = 1; i < rows; i++)
      (*array2D)[i] = (*array2D)[i - 1] + columns ;

}

int main()
{
	int rows = 3;
	int columns = 4;
	byte **array2D = NULL;

	get_mem2D(&array2D, rows, columns);

	int i, j;
	for(i = 0; i < rows; i++)
	{
		for(j = 0; j < columns; j++)
		{
			array2D[i][j] = i * columns + j + 1;
		}
	}

	for(i = 0; i < rows; i++)
	{
		for(j = 0; j < columns; j++)
		{
			printf("%d\t", array2D[i][j]);
		}
		printf("\n");
	}

	return 0;
}

       结果为：

1       2       3       4
5       6       7       8
9       10      11      12
       

      下面看看三维数组的动态分配:

#include <stdio.h>
#include <malloc.h>

typedef unsigned char byte;

void get_mem2D(byte ***array2D, int rows, int columns)
{
    *array2D = (byte**)calloc(rows, sizeof(byte*));

    (*array2D)[0] = (byte*)calloc(columns * rows, sizeof(byte));
	int i;
    for(i = 1; i < rows; i++)
	{
       (*array2D)[i] = (*array2D)[i - 1] + columns ;
	}
}

void get_mem3D(byte ****array3D, int frames, int rows, int columns)
{
    *array3D = (byte***)calloc(frames,sizeof(byte**));

	int j;
    for(j = 0; j < frames; j++)
	{
       get_mem2D( (*array3D)+j, rows, columns );
	}
}

int main()
{
	int rows = 3;
	int columns = 4;
	int frames = 10;

	byte ***array3D = NULL;

	get_mem3D(&array3D, frames, rows, columns);

	int i, j, k;
	for(i = 0; i < frames; i++)
	{
		for(j = 0; j < rows; j++)
		{
			for(k = 0; k < columns; k++)
			{
				array3D[i][j][k] = (j + 1) * 10 + k + 1;
			}
		}
	}

	for(i = 0; i < frames; i++)
	{
		printf("Frame number is %d\n", i + 1);
		for(j = 0; j < rows; j++)
		{
			for(k = 0; k < columns; k++)
			{
				printf("%d\t", array3D[i][j][k]);
			}
			printf("\n");
		}
		printf("\n\n");
	}

	return 0;
}

       结果为：

Frame number is 1
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 2
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 3
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 4
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 5
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 6
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 7
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 8
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 9
11      12      13      14
21      22      23      24
31      32      33      34


Frame number is 10
11      12      13      14
21      22      23      24
31      32      33      34


       至此，总算搞清楚了多数指针和多维数组的关系.

涛歌依旧
关注
专栏目录
C语言多级指针详解
summer
05-30 4655
指针可以指向一个普通类型的变量，例如int、double、char等，也可以指向一个指针类型的变量，如int*、double*、char*等。 如果一个指针指向的是另一个指针，我们就成他为二级指针，或者指向指针的指针。 将这种关系转换为C语言代码： int a=100; int *p1=&a; int **p2=&p1; 指针变量也是一种变量，也会占用内存空间，也可以...
VC读写多级指针（植物大战僵尸版）
03-28
VC读写多级指针（植物大战僵尸版）代码，学习修改植物大战僵尸
6、多级指针
懵逼是一种状态的博客
03-15 389
之前还是不太理解，这次之后感觉还是有点收获了，先看下面一段代码： #include <stdio.h> int main(void){ int i=10; int * p=&i; int ** q=&p; int *** r=&q; printf("%d\n",***r); return 0; } 下面是我对上面代码的理解，其实也只是我...
C语言学习笔记
zzq2006的博客
09-21 480
1.int* a；和int *a 分别表示什么意思？ int* a 表示定义一个a类型的int指针，int *a 则表示a为一个指针，指向一个int类型的变量。 int* a,b; 等价于 int *a；int b；而不等价于 int *a; int *b; 所以，为了避免出现这样的歧义，很多书上都进行了规范处理，统一将星号靠近变量名，也就是写成 int *p; 2.malloc函数是什么？ malloc功能是内存的动态存储区中分配一个长度为size的连续空间，返回指向这块内存的起始位置的指针。 同时上
神奇的多级指针！（指针的嵌套）
XuSs_的博客
10-27 2878
今天发现指针好神奇，难道这就是指针的嵌套吗？ 下面请看代码！ #include using namespace std; int main() { int i=5; int *p,**q,***l,****k; p=&i; q=&p; l=&q; k=&l; cout return 0; } 请看
视频编解码器JM8.6
01-11
总结来说，"视频编解码器JM8.6"是视频编码研究的重要工具，通过深入学习和分析其内部机制，不仅可以提升对视频编解码原理的理解，还可能为新的编码技术提供灵感。对于从事相关领域的工程师和学者，掌握和研究JM8.6...
基于JM8.6的H.264编解码器代码工程（注释）
06-24
**基于JM8.6的H.264编解码器代码工程（注释）** 在数字视频编码领域，H.264/AVC（Advanced Video Coding）是一种广泛采用的高效视频压缩标准，它在有限带宽下提供高质量的视频传输。JM（Joint Model）是H.264/AVC...
JM8.6源代码的解析
12-10
JM8.6中的注释可以帮助我们理解代码的功能和逻辑。 通过深入分析JM8.6的源代码，不仅可以提升对Java编程的掌握，还能了解软件工程的实践，包括但不限于架构设计、性能优化、异常处理、测试策略等。这对于任何Java...
JM8.6测试序列
12-07
【标题】"JM8.6测试序列"涉及的是视频编解码领域的一个特定测试资源，主要针对JM（Joint Model）软件平台的8.6版本。JM是JPEG-Motion JPEG 2000（JPEG 2000 Part 3: Multiple Component Transform and Coding ...
H.264测试软件JM8.6
04-07
6. **率失真优化**：JM8.6中的编码器会根据编码质量和比特消耗进行权衡，选择最佳编码策略。 通过分析JM8.6的源码，开发者和研究人员可以深入理解H.264的内部工作原理，包括宏块级的决策过程、熵编码的细节以及如何...
Golang与Java各方面使用对比（上）
热门推荐
BoringError的博客
10-04 1万+
本文只对比Golang与Java的基本情况、基本使用、结构体函数及指针三块内容，下一篇文章会对比面向对象、异常处理、并发编程及垃圾回收的差异。
易语言调用c 二级指针,让易语言也伪造实现指针型（转）
weixin_34404808的博客
05-19 311
该楼层疑似违规已被系统折叠隐藏此楼查看此楼指针型数据类型是一样十分强大的数据类型。在很多应用时用指针型可以便捷的进行一些操作。易没有指针型是一大憾事。但突然灵机一闪，其实可以给易伪造一份指针型变量。易的局部变量中的自定义数据类型变量实际是一个指针。平时操作的也是一个指针，只是开发人员接触不到。而易的参考属性是很有价值的东西，为什么这么说，因为我所想到的就是强制修改掉指针啊。子程序1(某指针变量)...
c语言中二级指针和二维数组,二级指针和二维数组
weixin_29940173的博客
05-19 201
C/C++ code// array2D 是一个指针，它指向一个数组，该数组的每个元素为一个指针，他指向每行的起始地址。int get_mem2D(byte **&array2D, int rows, int columns) // 传引用byte **&array2D。 这才是给你传入指针分配空间。{int i;// 给 行指针 分配空间。这里并不是给二维数组元素分配空间。if...
JM8.6编解码器中trace_enc.txt和trace_dec.txt文件的功能
认知 行动 坚持
11-26 8850
前面博文已经说过，在JM8.6编码端如何开启trace_enc.txt功能以及如何利用trace_enc.txt文件的信息来分析码流，在此，不再赘述.下面来看看在解码端如何开启trace_dec.txt. 在JM8.6解码端的define.h文件中有： #if defined _DEBUG #define TRACE 0 //!< 0:T
sprintf_s与_snprintf与_snprintf_s
weixin_34388207的博客
12-10 567
2011-11-14 0:15 MSDN页面分别如下： spirntf_s: http://msdn.microsoft.com/zh-cn/library/ce3zzk1k%28VS.80%29.aspx _snprintf: http://msdn.microsoft.com/zh-cn/library/2ts7cx93%28v=VS.90%29.aspx _s...
易语言指针转换及调用方法
weixin_30517001的博客
10-20 1244
取变量数据地址(变量)'//转换成指针类型,结果(整数型),注意变量不能使用控件属性带入.变量可以为【整数 字符 字节集等】 指针到字节集(整数型变量,长度) '//获取以上转换的整数型【指针】指向的数据,结果为【字节集】, 长度为欲转换的长度. DLL例子 ===================================== <<DLL部分>> &l...
JM8.6 的核心编码函数研究
专注HEVC，H.264，ffmpeg
08-20 1194
原地址：http://www.cnblogs.com/xkfz007/articles/2612755.html 摘 要： H.264 编解码软件JM 通常被作为算法研究或者实际应用的平台。理解JM 的程序结构是在其基础上进行进一步研究工作的前提。JM 中的编码函数encode_one_macroblock在程序实现编码算法的过程中起到核心的作用。这篇文章通过对程序中开销计算，关键全局变
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值