《C和指针》章节后编程练习解答参考——第8章

最新推荐文章于 2022-06-20 15:32:22 发布
最新推荐文章于 2022-06-20 15:32:22 发布
阅读量207 收藏 1
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/microxiami/p/5028234.html
版权

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         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,    // 0,0,X,X
 11         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,    // 0,1,X,X
 12         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,
 13         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,
 14         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,
 15         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,
 16 
 17         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,    // 1,0,X,X
 18         0,    0,    0,    0,    0,            0,    ' ',    0,    0,    0,        0,    0,    0,    0,    0,            0,    0,    0,    0,    0,    // 1,1,X,X
 19         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    'A',    0,        0,    0,    0,    0,    'x',
 20         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0xf3,    0,    0,        0,    0,    0,    0,    0,
 21         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    '\n',    0,        0,    0,    0,    0,    0,
 22         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,
 23 
 24         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,    // 2,0,X,X
 25         0,    0,    0,    0,    0,            0,    0,    0320,    0,    0,        0,    0,    0,    0,    0,            0,    0,    0,    0,    0,    // 2,1,X,X
 26         0,    0,    0,    0,    0,            0,    '0',    0,    0,    0,        0,    0,    '\'',    0,    0,        0,    '\121',    0,    0,    0,
 27         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,
 28         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    '3',    3,    0,
 29         0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    0,            0,    0,    0,    0,    125,
 30     };
 31 
 32 /*
 33     // 使用嵌套花括号初始化
 34     unsigned char char_value[3][6][4][5] = 
 35     {
 36         {    //0,X,X,X
 37             {    //0,0,X,X
 38                 { 0 },    //0,0,0,X    
 39             }
 40         },
 41         {    //1,X,X,X
 42             { 0 },    //1,0,X,X
 43             {    //1,1,X,X
 44                 { 0 },    //1,1,0,X
 45                 {    //1,1,1,X
 46                     0, ' '
 47                 }    
 48             },
 49             {    //1,2,X,X
 50                 { 0 },    //1,2,0,X
 51                 { 0 },    //1,2,1,X
 52                 { 0, 0, 0, 'A' },//1,2,2,X
 53                 {    //1,2,3,X
 54                     0, 0, 0, 0, 'x'
 55                 }        
 56             },
 57             {    //1,3,X,X
 58                 { 0 },    //1,3,0,X
 59                 { 0 },    //1,3,1,X
 60                 {    //1,3,2,X
 61                     0, 0, 0xf3
 62                 }    
 63             },
 64             {    //1,4,X,X
 65                 { 0 },    //1,4,0,X
 66                 { 0    },//1,4,1,X
 67                 {    //1,4,2,X
 68                     0, 0, 0, '\n'
 69                 }    
 70             }    
 71         },
 72         {    //2,X,X,X
 73             { 0 },    //2,0,X,X
 74             {    //2,1,X,X
 75                 { 0 },    //2,1,0,X
 76                 {    //2,1,1,X
 77                     0, 0, 0320
 78                 }        
 79             },
 80             {    //2,2,X,X
 81                 { 0 },    //2,2,0,X
 82                 {    //2,2,1,X
 83                     0, '0'
 84                 },
 85                 {    //2,2,2,X
 86                     0, 0, '\''
 87                 },
 88                 {    //2,2,3,X
 89                     0, '\121'
 90                 }        
 91             },
 92             { 0 },    //2,3,X,X
 93             {    //2,4,X,X
 94                 { 0 },    //2,4,0,X
 95                 { 0 },    //2,4,1,X
 96                 { 0 },    //2,4,2,X
 97                 {    //2,4,3,X
 98                     0, 0, '3', 3
 99                 }        
100             },
101             {    //2,5,X,X
102                 { 0 },//2,5,0,X    
103                 { 0 },//2,5,1,X    
104                 { 0 },//2,5,2,X                
105                 {    //2,5,3,X
106                     0, 0, 0, 0, 125
107                 }        
108             }        
109         }    
110     };
111 */
112 
113     for ( a = 0; a < 3; a++ )
114         for ( b = 0; b < 6; b++ )
115             for ( c = 0; c < 4; c++ )
116                 for ( d = 0; d < 5; d++ )
117                 {
118                     if ( char_value[a][b][c][d] != 0 )
119                         printf("char_value[%d][%d][%d][%d] = %d\n", a, b, c, d, char_value[a][b][c][d]);
120                 }
121 
122     getchar();
123     return 0;
124 }


8.3

 

 1 #include <stdio.h>
 2 
 3 #define N 3
 4 
 5 #define  TRUE  1
 6 #define  FLASE  0
 7 
 8 int
 9 identity_matrix(int mat[][N])
10 {
11     int i, j;    
12     for( i = 0; i < N; i++)
13     {
14         for( j = 0; j < N; j++)
15         {
16             if ( ( i == j ) && ( 1 != mat[i][j] ) )
17                 return FLASE;
18             if ( ( i != j ) && ( 0 != mat[i][j] ) )
19                 return FLASE;
20         }
21     }
22     return TRUE;
23 }
24 
25 void show_mat(int mat[][N])
26 {
27     int i, j;
28     for ( i = 0; i < N; i++)
29     {
30         for( j = 0; j < N; j++)
31         {
32             printf("%d\t", mat[i][j]);
33         }
34         putchar('\n');
35     }
36 }
37 
38 int main (void)
39 {
40     int mat[][N] = 
41     { 
42         { 1 },
43         { 0, 1 },
44         { 0, 0, 1}
45     };
46     
47     int state = identity_matrix(mat);
48     show_mat(mat);
49 
50     if ( state )
51     {
52         printf("Yes!\n");
53     }
54     else
55         printf("No!\n");
56 
57     getchar();
58     return 0;
59 }

 

8.4

 

 1 #include <stdio.h>
 2 
 3 #define  N  3
 4 
 5 #define  TRUE  1
 6 #define  FLASE  0
 7 
 8 int identity_matrix(int *mat, int n)    //判断矩阵是否为单位矩阵
 9 {
10     int i, j;    
11     for( i = 0; i < n; i++)
12     {
13         for( j = 0; j < n; j++)
14         {
15             if ( ( i == j ) && ( 1 != *mat ) )
16                 return FLASE;
17             if ( ( i != j ) && ( 0 != *mat ) )
18                 return FLASE;
19             mat++;
20         }
21     }
22     return TRUE;
23 }
24 
25 void show_mat(int *mat, int n)    //打印矩阵元素
26 {
27     int i, j;
28 
29     for ( i = 0; i < n; i++)
30     {
31         for( j = 0; j < n; j++)
32         {
33             printf("%d\t", *mat++);
34         }
35         putchar('\n');
36     }
37 }
38 
39 int main (void)
40 {
41     int mat[][N] = 
42     { 
43         { 1 },
44         { 0, 1 },
45         { 0, 0, 1}
46     };
47     
48     int state = identity_matrix( &mat[0][0], N);
49     show_mat(&mat[0][0], N);
50 
51     if ( state )
52     {
53         printf("Yes!\n");
54     }
55     else
56         printf("No!\n");
57 
58     getchar();
59     return 0;
60 }

 

8.5

 

 1 #include <stdio.h>
 2 
 3 #define  X  3
 4 #define  Y  2
 5 #define  Z  4
 6 
 7 void matrix_multiply(int *m1, int *m2, int *r, int x, int y, int z)
 8 {
 9     int i, j, k, sum;
10 
11     for ( i = 0; i < x; i++ )
12     {
13         for ( k = 0; k < z; k++ )
14         {
15             sum = 0;
16             for ( j = 0; j < y; j++ )
17             {
18                 sum += (*(m1+(i*y)+j)) * (*(m2+(j*z+k)));
19             }
20             *( r + (i*z) + k ) = sum;
21         }
22     }
23 }
24 
25 void show_mat(int *mat, int x, int y)    //打印矩阵元素
26 {
27     int i, j;
28 
29     for ( i = 0; i < x; i++)
30     {
31         for( j = 0; j < y; j++)
32         {
33             printf("%d\t", *mat++);
34         }
35         putchar('\n');
36     }
37     putchar('\n');
38 }
39 
40 int main (void)
41 {
42     int m1[X][Y] = 
43     {
44         { 2, -6 },
45         { 3,  5 },    
46         { 1, -1 }        
47     };
48 
49     int m2[Y][Z] =
50     {
51         { 4, -2, -4, -5 },
52         { -7, -3, 6, 7 }    
53     };
54 
55     int r[X][Z] = { 0 };
56 
57     printf("m1 = \n");
58     show_mat(&m1[0][0], X, Y);
59     printf("m2 = \n");
60     show_mat(&m2[0][0], Y, Z);
61 
62     matrix_multiply(&m1[0][0], &m2[0][0], &r[0][0], X, Y, Z);
63     printf("r = m1 * m2 = \n");
64     show_mat(&r[0][0], X, Z);
65 
66     getchar();
67     return 0;
68 }

 

转载于:https://www.cnblogs.com/microxiami/p/5028234.html

C和指针第八章编程练习
16的博客
03-14 426
8.8.1 #include <stdio.h> int main(void) { static char char_value[3][6][4][5] = { { { {}, {}, {}, {} }, { {}, {}, {}, {} }, { {}, {}, {}, {} }, { {}, {}, {}, {}
黑马程序员——C语言基础——指针编程练习题
Elors的博客
06-01 6085
------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 今天复习了一下指针的相关知识，并且在网上搜了一道小的编程练习题，大概题意如下： 有n个整数，使其前面各数顺序向后移m个位置，最后m个数变成最前面的m个数。
C和指针 第八章 代码答案
weixin_42385823的博客
03-16 430
#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 280
c语言第8章_指针答案第8 章 指针8.1 教学要点本章主要介绍指针的基本概念、指针变量的定义、指针变量的基本运算、指针作为函数的参数、指针和数组、指针和字符串、动态内存分配和使用等知识。首先要把基本概念讲清，一定要结合图例来说明变量、内存单元和地址之间的关系；本章重点难点较多，讲解时注意趣味性激发学生兴趣，通过对比演示来分析指针和普通变量的区别。8.1 节通过示例程序“寻找保险箱密码”引出指针的...
C和指针 第八章 习题
weixin_30268921的博客
08-24 362
　　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和指针课后习题（第八章）
zhouzhouzf的专栏
05-08 2601
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++ Primer Plus 编程练习源码工程 第15章
12-25
《C++ Primer Plus 编程练习源码工程 第15章》是针对C++初学者的一个宝贵资源，它包含了作者LeonardoLiuwenbo在学习《C++ Primer Plus》这本经典教材时所做的编程练习。这个章节聚焦于C++语言的深入特性，旨在通过...
源代码——第10章.zip
最新发布
04-23
标题 "源代码——第10章.zip" 暗示这是一个关于编程或计算机科学的压缩文件，其中包含一系列的C语言源代码文件。这些源代码可能是某个教程、课程或者项目的一部分，专注于第10章的内容。由于没有具体的标签，我们...
C++ Primer Plus（第六版）编程练习答案 第7章 函数——C++的编程模块
清水河C罗——Leonardo-Liu
07-10 6588
本章所有编程练习的工程源码可在此处下载（点击打开下载链接），供大家参考交流！   1. 编写一个程序，不断要求用户输入两个数，直到其中的一个为0。对于每两个数，程序将使用一个函数来计算它们的调和平均数，并将结果返回给main()，而后者将报告结果。调和平均数指的是倒数平均值的倒数，计算公式如下： 调和平均数=2.0*x*y/(x+y) 本题要求编写一个函数，该函数接受的输入参数为两个int...
C和指针 第8章 数组 8.8 编程练习
weixin_客子光阴的博客
06-20 284
C和指针 第8章 数组 8.8 编程练习
C和指针_编程练习_第8章_第8题
半人半鬼
07-21 185
/* 皇后是国际象棋中威力最大的棋子. 在大小为 8 * 8 的棋盘上, 皇后可以攻击其上, 下, 左, 右四个方向以及左上, 右上, 左下, 右下四个方向上的所有棋子. 我们是否能把 8 个皇后放在棋盘上, 它们中的任何一个都无法攻击其余的皇后? 这个问题被成为八皇后问题. 你的任务是编写一个程序, 找到八皇后问题的所有答案, 看一看一共有多少种答案. 提示: 如果你采用一种叫做"回溯法(backtracking)"的技巧, 就很容易编写出这个程序.
C和指针_编程练习_第8章_第7题
半人半鬼
07-21 188
/* 修改问题6 的array_offset函数, 使它访问以列为主序的伪数组, 也就是最左边的下标率先变化. 这个新函数array_offset2在其他方面与原先的那个函数一样. 例如: 假定arrayinfo数组包含了值3, 4, 6, 1, 5, -3, 3. 这些值提示我们所处理的是三维伪数组. 第一个下标范围从4 到6; 第二个下标范围从1 到5; 第三个下标范围从-3 到 3. 在这个例子中, array_offs
《C和指针》第八章书后问题
我喝花间一壶酒的博客
11-24 779
这道题其他的都比较简单，主要是划红线的两个会有问题。 首先 &ints 的结果并不是一个指向指针的指针，而是一个指向数组的指针。具体在8.1.1节有讲 所以 &ints 是一个指向含有20个整型元素的数组的指针，那么 &ints 的值就是这个数组中首个元素的地址，也就是100。 但是答案中 &ints + 4 的值是 116 是错误的，因为 &int...
C和指针---第八章：数组
weixin_34242331的博客
09-15 141
为什么80%的码农都做不了架构师？>>> ...
C和指针 第八章 数组 问题一
ruheshiluo的专栏
06-22 768
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和指针》第八章 数组
xiaoying1232的专栏
05-23 446
10一维数组名的值是一个指针常量，也就是第一个元素的地址
【C和指针】第八章（1）-->一维数组
皓皓松的博客
07-08 527
一、数组基本概念 数组是用来存储一组数据类型的构造数据类型 特点：只能存放一种类型的数据，数组里的数据成为元素 二、数组和指针的不同之处 说到数组，基本都会和指针扯上关系。 但是数组和指针是截然不同的 通过下面这张图片，我们应该知道数组名其实是一个指针常量（不可被改变） 三、数组元素的两种访问方法：下标访问和间接访问 （1）下标访问 （2）间接访问 用间接访问的方法实现杨辉
C--《C和指针》第8章读书笔记之效率问题
老白的博客
06-07 299
作者在第8章有几个小例子来测试指针的效率问题。他当年用的处理器是摩托罗拉的M6800，编译器不清楚。下面是他的例子。原谅我的电子版的太花了。。上面这个例子的反汇编行数比较多。运用了指针及一些技巧后，反汇编代码迅速降低，运行效率看起来变高了。但是，同样的代码我在VS2010上面试了下。上面第一个例子对应的代码如下：上面第2个例子对应的反汇编代码如下：我们看到，第二个运用指针的例子，在VS2010上面...
C和指针第八章笔记
sinat_39806420的博客
08-30 349
8.1一维数组 1.数组名是一个指针常量，是数组第一个元素的地址 2.当数组名作为sizeof的操作数（产生整个数组的大小）或者单目运算&的操作数时（产生一个指向数组的指针） 3.下标引用的优先级大于间接访问，自增一类的优先级也是要高于间接访问 4.指针和数组 声明一个数组时，编译器先为数组保留内存空间，再创建数组名，是一个常量指向空间起始位置，而声明指针时只为变量本身留一个空间 5.
.arch源代码分析——第二章详细解读
资源摘要信息: "arch源代码——第2章" 指的可能是一个关于“arch”主题的教学材料或者电子书籍的第二章的源代码文件，该文件被压缩成一个ZIP格式的压缩包。由于文件描述和标签没有提供额外信息，我们只能通过文件...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值