数组迭代循环中使用下标和指针的区别

最新推荐文章于 2025-07-28 20:45:06 发布
原创 最新推荐文章于 2025-07-28 20:45:06 发布 · 667 阅读 · 3 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#c语言 #算法 #指针
这篇博客探讨了在C语言中，使用数组下标和指针遍历数组时的效率差异。通过两组例子和对应的汇编代码分析，得出结论：在固定增量遍历时，指针可能更高效；寄存器指针比静态或堆栈指针效率更高；避免在运行时计算常量表达式。然而，考虑到可读性，通常以简洁和易懂为主，除非性能提升显著。

我们来看一下2组例子：

第一组例子：

下标表达式：

a = get_value();
array[a] = 0;

指针表达式：

a = get_value();
*(array + a) = 0;

第二组例子：

下标表达式：

int array[10], a;
for(a=0; a<10; a+=1) {
    array[a] = 0;
}

指针表达式：

int array[10], *ap;
for(a=array; a < array + 10; ap++) {
    *ap = 0;
}

这2组例子都是一个使用下标，一个使用指针，每组例子的2中方式都实现相同的效果，但这2组例子使用下标和指针访问数组元素效率是一样的吗？

第一组例子效率完全一致，第二组例子循环体所有区别，计数器1和整形长度相乘，然后和指针相加，每次执行乘法迅运算都是相同的1和4。而指针每次都是相同的1和4相乘，而且只是在编译时执行一次，后面就是把指针和4相加。

它们到底怎么工作的呢？接下来，我们就来研究一下：

一、先看一个下标版本

#include <stdio.h>

#define SIZE 50
int x[SIZE];
int y[SIZE];
int i;
int *p1, *p2;

void try1() {
    for(i = 0; i < SIZE; i++) {
        x[i] = y[i];
    }
}


int main () {
    try1();
    return 0;
}

编译获得汇编代码：

	.file	"main.c"
	.text
	.globl	x
	.bss
	.align 32
	.type	x, @object
	.size	x, 200
x:
	.zero	200
	.globl	y
	.align 32
	.type	y, @object
	.size	y, 200
y:
	.zero	200
	.globl	i
	.align 4
	.type	i, @object
	.size	i, 4
i:
	.zero	4
	.globl	p1
	.align 8
	.type	p1, @object
	.size	p1, 8
p1:
	.zero	8
	.globl	p2
	.align 8
	.type	p2, @object
	.size	p2, 8
p2:
	.zero	8
	.text
	.globl	try1
	.type	try1, @function
try1:
.LFB0:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$0, i(%rip)
	jmp	.L2
.L3:
	movl	i(%rip), %eax
	movl	i(%rip), %ecx
	cltq
	movl	y(,%rax,4), %edx
	movslq	%ecx, %rax
	movl	%edx, x(,%rax,4)
	movl	i(%rip), %eax
	addl	$1, %eax
	movl	%eax, i(%rip)
.L2:
	movl	i(%rip), %eax
	cmpl	$49, %eax
	jle	.L3
	nop
	nop
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE0:
	.size	try1, .-try1
	.globl	main
	.type	main, @function
main:
.LFB1:
	.cfi_startproc
	pushq	%rbp
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp
	.cfi_def_cfa_register 6
	movl	$0, %eax
	call	try1
	movl	$0, %eax
	popq	%rbp
	.cfi_def_cfa 7, 8
	ret
	.cfi_endproc
.LFE1:
	.size	main, .-main
	.ident	"GCC: (GNU) 10.2.1 20201016 (Red Hat 10.2.1-6)"
	.section	.note.GNU-stack,"",@progbits

我们只看try1这个函数的汇编实现：

编译器做了一些优化，这里.LFB0对try1函数做了初始化，然后跳到循环.L2，L2里面判断for循环条件，如果没超过49就执行循环体L3，所以这里的循环体就是我们要看的主要部分：

	movl	i(%rip), %eax
	movl	i(%rip), %ecx
	cltq
	movl	y(,%rax,4), %edx
	movslq	%ecx, %rax
	movl	%edx, x(,%rax,4)
	movl	i(%rip), %eax
	addl	$1, %eax
	movl	%eax, i(%rip)

循环体就一个x[i] = y[i]的赋值语句，对应的汇编代码：

# main.c:11:         x[i] = y[i];
	movl	i(%rip), %eax	# i, i.0_1
# main.c:11:         x[i] = y[i];
	movl	i(%rip), %ecx	# i, i.1_2
# main.c:11:         x[i] = y[i];
	cltq
	movl	y(,%rax,4), %edx	# y[i.0_1], _3
# main.c:11:         x[i] = y[i];
	movslq	%ecx, %rax	# i.1_2, tmp89
	movl	%edx, x(,%rax,4)	# _3, x[i.1_2]

将i读入eax寄存器(累积暂存器)，将i读入ecx寄存器（计数寄存器）,  cltq 等效于 movslq%eax,%rax，就是将eax的地址扩展后读入rax寄存器，然后将y的新地址读入到edx寄存器，接下来扩展ecx的地址，读入到rax寄存器，然后将edx寄存器读入到x的新地址。 这里我们看到有2次乘以4的操作，因为这里是整形，地址占4个字节。

二、指针版本

void try2() {
    for(p1 = x, p2 = y; p1 - x < SIZE; ) {
        *p1++ = *p2++;
    }
}

编译得到汇编：

try2:
.LFB1:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
# main.c:16:     for(p1 = x, p2 = y; p1 - x < SIZE; ) {
	movq	$x, p1(%rip)	#, p1
# main.c:16:     for(p1 = x, p2 = y; p1 - x < SIZE; ) {
	movq	$y, p2(%rip)	#, p2
# main.c:16:     for(p1 = x, p2 = y; p1 - x < SIZE; ) {
	jmp	.L5	#
.L6:
# main.c:17:         *p1++ = *p2++;
	movq	p2(%rip), %rdx	# p2, p2.4_1
	leaq	4(%rdx), %rax	#, _3
	movq	%rax, p2(%rip)	# _3, p2
# main.c:17:         *p1++ = *p2++;
	movq	p1(%rip), %rax	# p1, p1.6_4
	leaq	4(%rax), %rcx	#, _6
	movq	%rcx, p1(%rip)	# _6, p1
# main.c:17:         *p1++ = *p2++;
	movl	(%rdx), %edx	# *p2.5_2, _7
# main.c:17:         *p1++ = *p2++;
	movl	%edx, (%rax)	# _7, *p1.7_5
.L5:
# main.c:16:     for(p1 = x, p2 = y; p1 - x < SIZE; ) {
	movq	p1(%rip), %rax	# p1, p1.8_8
	subq	$x, %rax	#, _9
# main.c:16:     for(p1 = x, p2 = y; p1 - x < SIZE; ) {
	cmpq	$196, %rax	#, _9
	jle	.L6	#,
# main.c:19: }
	nop	
	nop	
	popq	%rbp	#
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc

这里L5是循环结束控制，使用了地址的方式，整形地址占4个字节，50个整数，就是200个字节，所以0-196个字节表示循环体范围。

L6就是循环体代码中分别读取p2和p1的地址，读取p2的值给p1，这里同样有2次乘以4的地址转换，效率看起来没啥变化。而且L5里面的循环条件更复杂一点。

 

三、指针版本+计数器版本

void try3() {
    for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
        *p1++ = *p2++;
    }
}

编译得到汇编代码：

try3:
.LFB2:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movl	$0, i(%rip)	#, i
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movq	$x, p1(%rip)	#, p1
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movq	$y, p2(%rip)	#, p2
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	jmp	.L8	#
.L9:
# main.c:23:         *p1++ = *p2++;
	movq	p2(%rip), %rdx	# p2, p2.9_1
	leaq	4(%rdx), %rax	#, _3
	movq	%rax, p2(%rip)	# _3, p2
# main.c:23:         *p1++ = *p2++;
	movq	p1(%rip), %rax	# p1, p1.11_4
	leaq	4(%rax), %rcx	#, _6
	movq	%rcx, p1(%rip)	# _6, p1
# main.c:23:         *p1++ = *p2++;
	movl	(%rdx), %edx	# *p2.10_2, _7
# main.c:23:         *p1++ = *p2++;
	movl	%edx, (%rax)	# _7, *p1.12_5
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movl	i(%rip), %eax	# i, i.13_8
	addl	$1, %eax	#, _9
	movl	%eax, i(%rip)	# _9, i
.L8:
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movl	i(%rip), %eax	# i, i.14_10
# main.c:22:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	cmpl	$49, %eax	#, i.14_10
	jle	.L9	#,
# main.c:25: }
	nop	
	nop	
	popq	%rbp	#
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc

使用计数器的方式，简化了循环条件的判断处理，虽然C代码看起来冗余一些，但是汇编效率可能好一丢丢......

但总体差别并不大，都会有复制指针值的

四、寄存器指针版本

void try4() {
    register int *p1, *p2;
    register int i;
    for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
        *p1++ = *p2++;
    }
}

编译得到汇编代码：

try4:
.LFB3:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
	pushq	%r13	#
	pushq	%r12	#
	pushq	%rbx	#
	.cfi_offset 13, -24
	.cfi_offset 12, -32
	.cfi_offset 3, -40
# main.c:31:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movl	$0, %ebx	#, i
# main.c:31:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movl	$x, %r12d	#, p1
# main.c:31:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	movl	$y, %r13d	#, p2
# main.c:31:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	jmp	.L11	#
.L12:
# main.c:32:         *p1++ = *p2++;
	movq	%r13, %rdx	# p2, p2.15_1
	leaq	4(%rdx), %r13	#, p2
# main.c:32:         *p1++ = *p2++;
	movq	%r12, %rax	# p1, p1.16_2
	leaq	4(%rax), %r12	#, p1
# main.c:32:         *p1++ = *p2++;
	movl	(%rdx), %edx	# *p2.15_1, _3
# main.c:32:         *p1++ = *p2++;
	movl	%edx, (%rax)	# _3, *p1.16_2
# main.c:31:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	addl	$1, %ebx	#, i
.L11:
# main.c:31:     for(i = 0, p1 = x, p2 = y; i < SIZE; i++) {
	cmpl	$49, %ebx	#, i
	jle	.L12	#,
# main.c:34: }
	nop	
	nop	
	popq	%rbx	#
	popq	%r12	#
	popq	%r13	#
	popq	%rbp	#
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc
.LFE3:
	.size	try4, .-try4
	.globl	main
	.type	main, @function

这里的循环体L12就高效一些了，因为指针变量直接保存在寄存器中的，直接使用硬件的地址自增模型直接增加值。

四、去掉计数器的纯寄存器指针版本

void try5() {
    register int *p1, *p2;
    for(p1 = x, p2 = y; p1 < &x[SIZE];) {
        *p1++ = *p2++;
    }
}

编译得到汇编代码：

try5:
.LFB4:
	.cfi_startproc
	pushq	%rbp	#
	.cfi_def_cfa_offset 16
	.cfi_offset 6, -16
	movq	%rsp, %rbp	#,
	.cfi_def_cfa_register 6
	pushq	%r12	#
	pushq	%rbx	#
	.cfi_offset 12, -24
	.cfi_offset 3, -32
# main.c:38:     for(p1 = x, p2 = y; p1 < &x[SIZE];) {
	movl	$x, %ebx	#, p1
# main.c:38:     for(p1 = x, p2 = y; p1 < &x[SIZE];) {
	movl	$y, %r12d	#, p2
# main.c:38:     for(p1 = x, p2 = y; p1 < &x[SIZE];) {
	jmp	.L14	#
.L15:
# main.c:39:         *p1++ = *p2++;
	movq	%r12, %rdx	# p2, p2.17_1
	leaq	4(%rdx), %r12	#, p2
# main.c:39:         *p1++ = *p2++;
	movq	%rbx, %rax	# p1, p1.18_2
	leaq	4(%rax), %rbx	#, p1
# main.c:39:         *p1++ = *p2++;
	movl	(%rdx), %edx	# *p2.17_1, _3
# main.c:39:         *p1++ = *p2++;
	movl	%edx, (%rax)	# _3, *p1.18_2
.L14:
# main.c:38:     for(p1 = x, p2 = y; p1 < &x[SIZE];) {
	cmpq	$x+200, %rbx	#, p1
	jb	.L15	#,
# main.c:41: }
	nop	
	nop	
	popq	%rbx	#
	popq	%r12	#
	popq	%rbp	#
	.cfi_def_cfa 7, 8
	ret	
	.cfi_endproc

这个版本C代码就很简洁，汇编代码也很高效，$x+200就是&x[SIZE], 由于SIZE是个常量，编译过程就会完成，这就是最好的实现。

结论：

1、当根据某个固定数目的增量在一个数组中移动时，使用指针变量将比使用下标产生效率更高的代码。

2、声明寄存器变量的指针通常比位于静态内存和堆栈中的指针效率更高。

3、如果可以通过测试一些已经初始化并经过调整的内容来判断循环是否应该终止，就不需要计数器帮助。

4、在运行时求值比&array[SIZE]这种常量表达式代价高。

 

但面向C程序员的，可读性很重要，所以在效率提高不很明显的情况下，以简洁可读性高为原则，越复杂风险越高。

数组的下标法和指针法查找数组中元素的不同
ALex_zry的博客
03-28 1940
总结文档的时候遇到了这个问题。在CSDN上看到一篇博客觉得有缺漏和误导性，所以自己总结一下。 原参考博客： https://blog.csdn.net/qq_20583039/article/details/47000985 博客作者说怀疑指针法查找元素比下标法更高效不一定正确，并且说当使用指针访问数组元素（注意是新创建一个指针指向数组名）要慢于通过数组下标访问。 这个说法是正确的，...
c语言中下标法和指针法,C语言 下标法和指针法的比较
weixin_34566436的博客
05-19 2231
编程序 将一维数组中元素向右循环移N次。要求用下标法和指针法两种方法实现例如 元素为0，1，2，3，4，5，6，7，8，9，10位移3次后变成8，9，10，0，1，2，3，4，5，6，7。==========================下标法#includevoid main(){int a[11]={0,1,2,3,4,5,6,7,8,9,10};int N;int i,j,temp;pri...
指针的优点（二）、对比数组下标法和指针法冒泡排序，看如何提高访问数组的效率
一匹刚学打乒乓球的老马
05-18 1453
一维数组
指针和数组分析
weixin_46571142的博客
11-08 1009
数组的本质： (1)数组是一段连续的内存空间 (2)数组的大小为sizeof(array_type)*array_size (3)数组名可看做指向数组第一个元素的常量指针 指针的运算 指针与整数的运算规则为： p+n; (unsigned int)p+n*sizeof(*p); 指针之间的减法运算 (1)指针之间只支持减法运算 (2)参与减法运算的指针类型必须相同 p1-p2; ((unsigned int)p1 - (unsigned int)p2) / sizeof(type) 注意： 1.只
数组的访问-下标访问和指针引用访问哪个更快？
weixin_47644373的博客
05-27 2958
昨天我们上c语言课，老师在讲数组的访问的时候，说到：数组的指针访问比下标访问更快原话在谭浩强先生的c程序设计第五版-p229最初我对这个有点疑问：指针访问不应该是间接访问问嘛？为什么会比下标直接放更快呢？课后我去问老师，老师说因为下标访问需要计算位置，int类型加4字节，而指针只需要找门牌号，效率更高……这样似乎合情合理，但事实真的是这样吗？ 后来我决定设计一个程序测试一下，我开了一个10万的数组，为了保证真实性，使用devc++，使用随机数赋值，然后访问（）逐一遍历，可是事实并没有如我所愿，于是我试了二十
【Java】for循环和foreach的区别
weixin_45995287的博客
04-13 2637
文章目录前言一、for循环二、foreach循环总结 前言 for循环和foreach的区别 以下仅是我为了记忆梳理的过程，有任何错误感谢各位指出！ 一、for循环 for循环是基于下标来定位循环的，也就是说for循环适用于带有下标的操作（例如数组），同时for循环可以进行集合的增删，但for循环在进行完增删操作后，由于是基于下标来定位循环的，就会导致都不到的问题，由于集合长度已发生变化会抛出IndexOutOfBoundsExcecption(下标越界异常)异常 二、foreach循环 foreach
指针迭代和递归
最新发布
m0_70978862的博客
07-28 918
如果数组指针为int型，则指针变量的基类型也为int型， p = &a[0], 把a[0]元素的地址赋给指针变量p，也就是使p指向a数组的第0号元素。当（*p）++，表达的是首先*p指的是啊a[0]的值然后进行++运算，此时数组变为22345.....当为*p++时先进行++运算表达式没有加但是值加了，再进行指针运算，最后指针会指向a[1]。对指针进行加法运算，及p+n，其结果依旧是一个指针，新的指针是在原来的地址值基础上加上n(sizeof(基类型))个字节。注释的是迭代操作，下面的是递归。
浅析Java中for循环和foreach循环的区别
qq_50864729的博客
05-06 6517
目录 一、for循环 二、foreach循环 三、区别 四、两者效率比较 一、for循环 1.语句最简形式为： for( ; ; ) 2.一般形式为： ​ for（单次表达式;条件表达式;末尾循环体）{ 中间循环体； } ​ 二、foreach循环 1、foreach也叫增强for循环，foreach其实是for循环的一个特殊简化版。 2、foreach的书写格式： for（元素类型 元素名称 ： 遍历数组（集合）（或者能进行迭代的））{ 语句 } ..
TS —数组的基础应用
sjsjsjsj1010的博客
04-04 2626
ts中数组的基础应用，包括增删改查等API操作
while，for与结构体指针学习心得
zhangyizhongcom的博客
03-21 239
对于结构体数组一样定义一个结构体变量structur student stu[]；与指针structur student *p；如定义一个结构体变量structur student stu；与指针structur student *p；与数组一样，结构体变量的起始地址就是这个结构体变量的指针。for循环可x1不在这里定义，在for循环之前定义都行。x3也一样可以不在这里定义，可在for循环中定义使用。在使*（p+1）来输出stu这个数组剩下的值。最后（*p）.num来进行结构体的输入输出等。
C小知识点 ： 数组和指针遍历的效率
iotflh的博客
12-02 2376
#include #include int main() { clock_t start; clock_t end; int b[100000]; int a[100000]; int *pa; int *pb; int k; int i; int * pend = &a[20000]; start = clock(); for (k = 0; k <20000
C语言，数组循环哪家好，指针or下标？
weixin_40960130的博客
12-20 709
C语言中数组遍历是用指针快还是下标快呢？快来看一看吧～
利用下标获取指针的数值
重新做个学生
10-13 2665
（1）当定义一个指针数据之后 int *p ,通过*p 获取指针指向的数据。 （2）当指针指向一个数组的时候，int *p , int a[3] , p=a ; 因为数组名就是指向数组第一个数值的地址。如下 int main() { int *p=NULL; int a[3]={0,1,2}; p=a; printf("a[1] is %d\n",a[1]); printf("p[1] is %d\n",p[1]); printf("*(p+1) is %d\n",*(p+1))...
C++ 数组指针下标的理解【个人学习笔记用】
qq_50031809的博客
04-10 5597
一、C++中传递参数的三种方法 1. 直接按值传递 形如： int fun1(int a){ printf(a); } 该方法会在调用函数时把传入的参数copy一份后在函数中进行操作，不会影响到原来的参数。 2. 指针（地址）传递 形如： int fun1（int *a）{ printf(*a); } 将参数的地址（指针）传进来，函数的操作会直接影响到原参数。函数内部使用时候需要取值操作，如 *a 3.引用传递 形如： int fun1（int &a）{ printf(a); }
C++中数组和指针的关系（区别）详解
weixin_44966641的博客
08-13 2770
C++中数组和指针的关系（区别）详解 本文转自：http://c.biancheng.net/view/1472.html 博主在阅读后将文中几个知识点提出来放在前面： 没有方括号和下标的数组名称实际上代表数组的起始地址，这意味着数组名称实际上就是一个指针。 在数学语句中使用指针时，它不像常规变量那样工作。 向指针添加值时并要解引用时，括号非常重要。 array[index] 相当于 *(array + index)。 C++ 不会对数组执行边界检查。 不仅指针符号可以与数组名称一起使用，而且下标符号也可
c语言下标法 数组名 指针,访问数组的下标法和指针法的区别
weixin_35728286的博客
05-23 3758
本文源自《C++沉思录》第12章，添油加醋一番，仅供娱乐。在C++中，访问一个数组中的元素有两种方法，一种使用下标访问，另一种是用指针，代码写法如下void f(int& i); // 假设存在这样一个函数int a[N]; // 这是一个数组// 下标法遍历整个数组for (int i = 0; i < N; ++i) {f(a[i]);}// 指针法遍历整个数组f...
C语言数组下标是指针,数组与指针
weixin_31951319的博客
05-19 1295
前面我们已经知道,通过数组下标可以确定数组元素在数组中的顺序和存储地址。由于每个数组元素 相当于一个变量,因此指针变量可以指向数组中的元素,也就是说可以用指针方式访问数组中的元素。 对一个指向数组元素的指针变量的定义和赋值方法,与指针变量相同。例如:inta[10];/*定义a为包含10个整型数据的数组*/int*p;/*定义p为指向整型变量的指针*/p=&a[0];...
C++ 中数组的指针和下标
geekwang的专栏
04-19 7765
我们知道，当我们使用数组名的时候实际上使用的是指向数组首元素的指针，实际上，使用数组名参加下标运算时本质上参加运算的仍然是指向数组首元素的指针： int arr[] = {3, 5, 2, 1, 4, 5, 6, 2}; int i = arr[2]; // i 的值是 2 arr[2] 实际的运算过程是这样的：*(arr + 2)； 其实，只要指针指向的是数组中的某一个
汇编学习--数组
热门推荐
gclome的博客
03-09 1万+
数组是相同数据类型的元素的集合，它们的内存中按顺序连续存放在一起。在汇编状态下访问数组一般是通过基址加变址寻址实现的。 0x01 先找一个数组访问的C语言代码 #include<stdio.h> int main() { static int a[3]={0x11,0x22,0x33}; int i...
数组的下标访问和指针访问方式效率分析比较
caomiao2006的专栏
03-28 7452
1、 int array[10], a; for (a = 0; a {     array[a] = 0; } 该组使用下标方式赋值，为了对下标表达式求值，编译器在程序中插入指令，取的a的值，并把它与整型的长度（也就是4）相乘，这个乘法需要花费一定的时间和空间 2、 int array[10], *ap; for (ap = array; ap {     *ap =
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值