C和指针---第八章：数组

最新推荐文章于 2022-12-03 18:10:41 发布
最新推荐文章于 2022-12-03 18:10:41 发布
阅读量135 收藏
点赞数
文章标签： c/c++
原文链接：https://my.oschina.net/voler/blog/161537
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

8.1 一维数组

8.1.1 数组名 

int a;
int b[4];
那么，b的类型是什么？实际上不能说b表示的是整个数组。

数组名的值是一个指针常量，也就是数组第一个元素的地址。它的类型取决于数组元素的类型：如果它们是int类型，那么数组名的类型是“指向int的常量指针”；如果它们是其他类型，那么数组名的类型就是“指向其他类型的常量指针。”

但数组和指针是不同的。例如：数组具有确定数量的元素，而指针指示一个标量值。编译器用数组名来记住这些属性。只有当数组名在表达式中使用时，编译器才会为它产生一个指针常量。且指针常量是不可改变的： 

#include <stdio.h>

int main(void)
{
	int a[2] = {1,2};
	a = (int*)100;

	return 0;
}
备注：这段代码是错误的。

因为指针常量所指向的是内存中数组的起始位置，如果修改这个指针常量，唯一可行的操作就是把整个数组移动到内存的其他位置。但是，在程序完成链接之后，内存中数组的位置是固定的，所以当程序运行时，再想移动数组就为时已晚。因此，数组名的值是一个指针常量。

只有在两种场合下，数组名并不用指针常量表示---就是当数组名作为sizeof操作符或单目操作符&的操作数时。sizeof返回整个数组的长度，而不是指向数组的指针的长度。 

sizeof(arr) / sizeof(*arr);//计算数组的长度
取一个数组名的地址所产生的是一个指向数组的指针。考虑下面这个例子： 
int a[10];
int b[10];
int *c;
c = &a[0];
表达式&a[0]是一个指向数组第一个元素的指针。所以它等价于： 
c = a;
而下面的运算是非法的： 
b = a;//a,b为指针常量
a = c;//指针常量不可修改
8.1.2 下标引用 
int array[10];
int *ap = array + 2;
ap     = array + 2 或 &array[2]

*ap = array[2]

ap[0] = *(ap) = array[2]

ap+6 = array + 8 或 &array[8]

*ap+6 = array[2] + 6

*(ap+6) = array[8]

ap[6] = array[8]

&ap = ap的地址，未知

ap[-1] = array[1]

ap[9] 非法，越界

8.1.3 指针与下标

规则：下标绝不会比指针更有效率，但指针有时会比下标更有效率。

例子：下标初始化 

int array[10];
int a;
for ( a = 0; a < 10; a++ ){
	array[a] = 0;
}
指针初始化： 
int array[10];
int *ap;
for ( ap = array; ap < array + 10; ap++ ){
	*ap = 0;
}
两者的区别在于：

在下标初始化中，a是相对于&array[0]进行偏移计算的，所以在运行阶段要进行10次的偏移计算。而ap是相对于上一个指针（ap-1）进行偏移计算的，而偏移量固定下来，所以在运行阶段只要进行1次偏移的计算。

而下面的代码只进行一个的偏移运算，故效率一样。 

int array[10];
int *ap;
for ( ap = array; ap < array + 10; ap++ ){
	*ap = 0;
}
a = get_value();
*( array + a ) = 0;
8.1.5 数组和指针

指针和数组并不相等的。 

int a[5];
int *b;
声明一个数组时，编译器将根据声明所指定的元素数量为数组保留内存空间，然后再创建数组名，它的值是一个常量，指向这段空间的起始位置。声明一个指针变量时，编译器只为指针本身保留内存空间，它并不为任何整型值分配内存空间。而且，指针变量并未被初始化为指向任何现有的内存空间。

所以*a是合法的，而*b则是未定义的。

b++可以通过编译，但是由于a是指针常量，a++却无法通过编译。

8.1.6 作为函数参数的数组名

如何理解C语言中传递数组名的时候依旧是传值而不是传址呢？请看下面的例子： 

#include <stdio.h>

void strcpy( char *buffer, char const *string )
{
	while ( ( *buffer++ = *string++) != '\0' ){
		;
	}
}

int main(void)
{
	char buffer[] = "hello";
	char string[] = "world";
	printf("%x\n", buffer);
	strcpy( buffer, string );
	printf("%s\n", buffer);
	printf("%x\n", buffer);

	return 0;
}
程序输出：

我们会发现，buffer的地址根本就没有改变过。所以，实际上的传值，副本是buffer(指针)而不是*buffer（指针所指向的值），所以buffer并为被改变，而*buffer则可以被改变。

我们这里对const进行一次复习： 

char  *const string =  "hello";
string[0] = 'a';
这是合法的，const修饰的是char*，表明指针所指向的内容不可被修改，所以下面代码有误： 
char  *const string =  "hello";
string = "hello";
同样的道理，下面代码是正确的： 
char  const *string =  "hello";
string = "hello";
而下面这段代码则有误： 
char  const *string =  "hello";
string[0] = 'a';
8.1.7 声明数组参数 
int strlen( char *string );
int strlen( char string[] );
两种方式都正确，但是指针方式更准确一些。


8.2 多维数组

如何解释多维数组呢？ 

int a;
int b[10];
int c[6][10];
int d[3][6][10];
a是个简单的整数，b增加了1维，故为一个向量，包含10个整型元素。c只是在b的基础上增加一维，所以c为包含6个元素的向量，而每个元素本身是一个包含10个整型元素的向量。而d包含3个元素的数组，每个元素包含6个元素的数组，而这6个元素中的每一个又都是包含10个整型元素的数组。

8.2.2 数组名

一维数组名的值是一个指针常量，它的类型是“指向元素类型的指针”。而多维数组，如： 

int matrix[3][10];
中的matrix则是一个指向一个包含10个整型元素的数组的指针。


8.2.4 指向数组的指针 

int matrix[3][10];
int *mp = matrix;
声明是否正确？答案是否定的。mp被声明为一个指向整型的指针。但是matrix并不是一个指向整型的贺子珍，而是一个指向整型数组的指针。那我们如何声明指向整型数组的指针呢？我们必须先声明指针，然后在指针的基础上声明数组，所以下面的括号是必要的： 
int (*p)[10] = matrix;
10为什么是必要的呢？因为我们进行指针偏移的时候，要确定偏移量是多少。下面这段代码说明了二维数组的指针声明方式： 
#include <stdio.h>


int main(void)
{
	int matrix[3][10];
	int i = 0; 
	int j = 0;
	int k = 0;
	int (*p)[10] = matrix;
	for ( i = 0; i < 3; i++ ){
		for ( j = 0; j < 10; j++ ){
			matrix[i][j] = k++;
		}
	}
	
	printf("%d\n", **p);
	printf("%d\n", **( p + 1 ));

	return 0;
}
程序输出：

当然，如果想读取matrix[1][5],我们可以这样编写代码： 

printf("%d\n", *( *( p + 1 ) + 5 ) );
多编写几次就习惯了。

由于多维数组的存储方式依旧是顺序存储的，所以如果我们希望逐个访问数据中的元素，那应该如何声明？请看下面的代码： 

#include <stdio.h>


int main(void)
{
	int matrix[3][10];
	int i = 0; 
	int j = 0;
	int k = 0;
	int *p = matrix[0];
	//或者为&matrix[0][0]
	for ( i = 0; i < 3; i++ ){
		for ( j = 0; j < 10; j++ ){
			matrix[i][j] = k++;
		}
	}
	
	printf("%d\n", *( p + 15 ) );

	return 0;
}
程序输出：

8.2.5 作为函数参数的多维数组 

int matrix[3][10];
func2( matrix );
那么，函数原型是什么？ 
void func2( int (*mat)[10] );
void func2( int mat[][10] );
两种都可以，但是第一种更好，因为代表的含义是：指向整型数组的指针。

当然，下面这个函数原型是错误的：（这个我之前还以为是正确的） 

void func2( int **mat );
8.3 指针数组

我们用一个例子说明指针数组的作用： 

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

int lookup_keyword( char const * const desired_word, char const * keyword_table[])
{
	char const **kwp;

	for ( kwp = keyword_table; *kwp != NULL; kwp++ ){
		if ( 0 == strcmp( desired_word, *kwp ) ){
			return kwp - keyword_table;
		}
	}

	return -1;
}

int main(void)
{
	char const *keyword[] = {
		"do",
		"for",
		"if",
		"register",
		"return",
		"switch",
		"while",
		NULL
	};

	printf("%d\n", lookup_keyword( "if", keyword ) );
	printf("%d\n", lookup_keyword( "return", keyword ) );
	printf("%d\n", lookup_keyword( "hello", keyword ) );

	return 0;
}
程序输出：

习题：

0. 判断字符串是否为回文字符： 

#include <stdio.h>

int isRight( char *buffer )
{
	char *temp;
	for ( temp = buffer; *temp != '\0'; temp++ ){
		;
	}
	temp--;

	while ( buffer < temp ){
		if ( *buffer != *temp ){
			return 0;
		}
		buffer++;
		temp--;
	}

	return 1;
}

int main(void)
{
	printf("%d\n", isRight( "helloollehh" ) );

	return 0;
}
3，4. 
#include <stdio.h>

int isIdentity( int (*arr)[10], int len )
{
	int i = 0; 
	int j = 0;
	for ( i = 0; i < len; i++ ){
		for ( j = 0; j < len; j++ ){
			if ( i == j ){
				if ( 0 == arr[i][j] ){
					return 0;
				}
			}
			else{
				if ( 1 == arr[i][j] ){
					return 0;
				}
			}
		}
	}

	return 1;
}

int main(void)
{
	int a[10][10];
	int i = 0;
	int j = 0;
	for ( i = 0; i < 10; i++ ){
		for ( j = 0; j < 10; j++ ){
			if ( i == j ){
				a[i][j] = 1;
			}
			else{
				a[i][j] = 0;
			}
		}
	}
	printf("%d\n", isIdentity( a, 10 ) );

	a[3][4] = 1;
	printf("%d\n", isIdentity( a, 10 ) );

	return 0;
}

程序输出：

5. 

#include <stdio.h>

void matrix_multiply( int (*m1)[2], int (*m2)[4], int (*r)[4], int x, int y, int z )
{
	int i = 0; 
	int j = 0;
	int k = 0;
	int m = 0; 
	int n = 0;
	for ( i = 0; i < x; i++ ){
		for ( j = 0; j < z; j++ ){
			for ( k = 0; k < y; k++ ){
				r[m][n] += m1[i][k] * m2[k][j];
			}
			n++;
		}
		m++;
		n = 0;		//记得清零
	}
}

int main(void)
{
	int m1[3][2] = { 2, -6, 3, 5, 1, -1 };
	int m2[2][4] = { 4, -2, -4, -5, -7, -3, 6, 7 };
	int r[3][4];
	int i = 0;
	int j = 0;

	for ( i = 0; i < 3; i++ ){
		for ( j = 0; j < 4; j++ ){
			r[i][j] = 0;
		}
	}

	matrix_multiply( m1, m2, r, 3, 2, 4 );
	for ( i = 0; i < 3; i++ ){
		for ( j = 0; j < 4; j++ ){
			printf("%d ", r[i][j]);
		}
		printf("\n");
	}

	return 0;
}

程序输出：


8. 智商不够，写不出八皇后问题，以下答案摘自网站上： 

#include <stdio.h>

int
is_safe(int rows[8], int x, int y)  
{
	int i;

	for (i=1; i <= y; ++i) {
		if (rows[y-i] == x || rows[y-i] == x-i || rows[y-i] == x+i)
			return 0;
	}

	return 1;
}

void
putboard(int rows[8])  
{
	static int s = 0;
	int x, y;

	printf("\nSolution #%d:\n---------------------------------\n", ++s);
	for (y=0; y < 8; ++y) {
		for (x=0; x < 8; ++x)
			printf(x == rows[y] ? "| Q " : "|   ");
		printf("|\n---------------------------------\n");
	}
}

void
eight_queens_helper(int rows[8], int y)
{
	int x;

	for (x=0; x < 8; ++x) {
		if (is_safe(rows, x, y)) {
			rows[y] = x;
			if (y == 7)
				putboard(rows);
			else
				eight_queens_helper(rows, y+1);
		}
	}
}

int main()
{
	int rows[8];

	eight_queens_helper(rows, 0);

	return 0;
}



转载于:https://my.oschina.net/voler/blog/161537

weixin_34242331
关注
C与指针书中源码（Pointers on C）
03-25
c与指针这本书的例子程序，原书是国外的大牛写的 我拿来分享一些
C和指针 第八章 代码答案
weixin_42385823的博客
03-16 417
#include<float.h> #include<stdio.h> static double income_limits[] = { 0,23350,56550,117950,256500,DBL_MAX }; static float base_tax[] = { 0,3502.5,12798.5,31832.5,81710.5 }; static float percentage[] = { .15,.28,.31,.36,.396 }; double single_..
c语言第八章指针答案,c语言第8章_指针答案.pdf
weixin_39690105的博客
05-21 271
c语言第8章_指针答案第8 章 指针8.1 教学要点本章主要介绍指针的基本概念、指针变量的定义、指针变量的基本运算、指针作为函数的参数、指针和数组、指针和字符串、动态内存分配和使用等知识。首先要把基本概念讲清，一定要结合图例来说明变量、内存单元和地址之间的关系；本章重点难点较多，讲解时注意趣味性激发学生兴趣，通过对比演示来分析指针和普通变量的区别。8.1 节通过示例程序“寻找保险箱密码”引出指针的...
C和指针 第八章 习题
weixin_30268921的博客
08-24 356
　　8.5矩阵运算，A是一个x行，y列矩阵，B是y行z列矩阵，把A和B相乘，结果是另外一个x行z列矩阵，每个位置的值由下公式决定,编写函数： #include <stdio.h> void matrix_mutiply(int *m1, int *m2, int *r, int x, int y, int z) { //sum为求和值 int i, j,...
《C和指针》第八章书后问题
我喝花间一壶酒的博客
11-24 765
这道题其他的都比较简单，主要是划红线的两个会有问题。 首先 &ints 的结果并不是一个指向指针的指针，而是一个指向数组的指针。具体在8.1.1节有讲 所以 &ints 是一个指向含有20个整型元素的数组的指针，那么 &ints 的值就是这个数组中首个元素的地址，也就是100。 但是答案中 &ints + 4 的值是 116 是错误的，因为 &int...
c语言指针数组-·详解数组指针与指针数组
04-25
在C语言中，指针和数组是两种非常重要的数据结构，它们可以...以上内容详细阐述了C语言中数组指针和指针数组的概念，以及如何通过指针操作数组，包括一维数组和多维数组。理解这些概念对于编写高效的C程序至关重要。
第8章 指针-3字符数组和字符指针 - 字符串的输入和输出1
08-03
总结来说，本章介绍了字符数组和字符指针在C语言中处理字符串的基本概念和常见操作，包括如何用循环输出字符串、如何使用`scanf`和`gets`进行字符串输入、以及它们对回车的不同处理方式，同时强调了安全性和指针在...
C语言：数组与指针详解
最新发布
逆鳞_Kevin的博客
12-03 8049
本文章为大家重点讲解数组与指针方面的运用，涵盖基础内容与重点知识
C和指针---数组
m0_49416708的博客
08-05 185
1.下标引用 int array[10]; int ap = array + 2; 说明： ap[0]：C的下标引用和间接访问表达式是一样的， 对等的表达式是(ap + (0)),即array[2] ap+6：对等的表达式是array+8或&array[8] *(ap + 6)：= array[8] = ap[6] ap[-1]：ap指向第3个元素，使用偏移量-1使我们得到它的前一个元素即array[1] 2.指针的效率 当根据某个固定数目的增量在一个数组中移动时，使用指针变量将比使用下标产生效率更
C语言 数组-结构体-指针
weixin_42522386的博客
06-10 1929
变量 变量是计算机这存储的数据，并且这个数据是可以变化的。但数据并不是直接存放在内存中，而是先申请内存空间（按照变量的类型申请一个合适大小的空间），然后将变量值放入空间中。 int a = 5； 与 int a； a = 5；等价，都是先申明一个int空间，int占用4个字节的内存，然后再将"5"存储到这个4个字节中。 int main(void) { printf("%d\n",sizeof(int));//占4个字节 printf("%d\n",sizeof(float));//占4字节 pri
《C和指针》章节后编程练习解答参考——第8章
weixin_30617737的博客
12-08 204
8.1 1 #include <stdio.h> 2 3 int main (void) 4 { 5 int a, b, c, d; 6 7 // 不使用嵌套花括号初始化 8 unsigned char char_value[3][6][4][5] = 9 { 10 ...
C和指针 第八章 数组 问题一
ruheshiluo的专栏
06-22 757
C和指针 第八章 数组 问题一  定义 int a[20]; int *ip = a + 3; 假定a数组在内存的起始位置是100.请问表达式a, &a,&a[4],&a+4和ip,&ip,&ip[4],&ip+4的值为多少？ 很容易知道，a = 100; &a = 100; &a[4] = 116 . ip = 112; &ip值未知(假定某次为8000); &ip[4] = 1
C和指针之判断参数在关键字字符串列表中是否匹配
码莎拉蒂
11-12 6518
1、题目 *判断参数是否与一个关键字列表任何单词匹配 *并返回匹配的索引值，如果没有找到返回-1 2、代码实现 #include #include #include /** *判断参数是否与一个关键字列表任何单词匹配 *并返回匹配的索引值，如果没有找到返回-1 **/ int lookup_keyword(const
C和指针课后习题（第八章）
zhouzhouzf的专栏
05-08 2590
8.2 #include #include #include static double income_limits[] = { 0,23350,56550,117950,256500,DBL_MAX }; static double tax[] = { 0,3502.50,12789.50,31832.50,81710.50 }; static double p[] =
《C和指针》笔记
flameboy的博客
05-05 963
第一章 快速上手 总结： 1.所有C程序必须有一个main函数，它是程序执行的起点。 2.printf函数执行格式化输出，scanf用于格式化输入，getchar和putchar分别执行非格式化字符的输入和输出。 3.从逻辑上删除一段C代码，更好的办法是用#if指令。 例：#if 0 /* 代码*/ #endif 4.C语言中，数组参数是传址调用，而标量和常量是按...
C和指针学习笔记
zhouyuming_hbxt的博客
05-10 388
在C语言中，数组参数是以引用（reference）形式进行传递的，也就是传址调用，而标量和常量则是按值（value）传递的。 应该使用typedef而不是#define来创建新的类型名，因为后者无法正确处理指针类型，例如： #define d_ptr_to_char char * d_ptr_to_char a,b; 正确的声明了a，但是b却被声明为一个字符。在定义更为复杂的类
c和指针笔记
Nuko的博客
07-29 152
文章目录作用域链接属性static和extern存储类型static移位操作符指针 参考资料：c和指针。     作用域 作用于分为文件作用域、函数作用域、代码块作用域、原型作用域。 文件作用域(file scope) 代码块之外的声明的标识符都具有文件作用域，从它们声明之处到源文件结尾处都可以访问。 原型作用域(prototype scope) 原型作用域只适用于在函...
c语言数组题难的,这个C语言题目我感觉你很可能会错。。。
weixin_39887748的博客
05-21 168
原标题：这个C语言题目我感觉你很可能会错。。。各位，今儿给大家带来一个不错的C语言试题，此题对你在C中的数组理解与掌握是个不错的检查，话不多说，请看题： 问题是会输出什么？我们就开门见山了，通过阅读代码发现本体主要考察以下四方面： 数组的指针法访问 ；数组名和数组名取地址的应用与区别； sizeof关于数组名和其他变量的用法； 强制类型转换。解析之前我们有两点需要明确：1、在C中，几乎所有使用数组...
C程序设计：第五章详解-数组与指针
"C语言程序设计的第六讲，主要探讨了第五章——数组与指针。本章节深入讲解了数组的定义、初始化、存储方式以及数组名的特性，并通过实例展示了如何查找一维数组中的最大值和最小值。" 在C语言中，数组是一种重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值