关于二维数组地址和指针之间的赋值

合集下载

c语言 char 二维数组的赋值方式

很久以来，C语言一直是编程领域中最重要、最基础的编程语言之一。

而在C语言中，char类型的二维数组赋值方式是一个基础且重要的概念。

通过本文的探讨和解释，我将带你深入了解这一概念，从而让你更好地掌握C语言编程的基础知识。

1. 直接赋值法我们来看一种最简单直观的赋值方式，即直接赋值法。

在C语言中，我们可以通过以下方式对char类型的二维数组进行直接赋值：```cchar arr[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};```在这种赋值方式中，我们可以清晰地看到每个元素的赋值过程，即按照每一行逐个元素地进行赋值。

这种方法简单直接，易于理解和实现，是C语言中常用的赋值方式之一。

2. 使用循环赋值除了直接赋值法，我们还可以通过循环来对char类型的二维数组进行赋值。

具体代码如下：```cchar arr[2][3];char temp[] = {'a', 'b', 'c', 'd', 'e', 'f'};for (int i = 0; i < 2; i++) {for (int j = 0; j < 3; j++) {arr[i][j] = temp[i * 3 + j];}}```在这种赋值方式中，我们利用了循环结构，通过下标的变化来逐个赋值。

这种方法在一些特定的情况下更加灵活，对于需要动态赋值的场景十分有用。

3. 利用指针赋值除了上述两种方法外，我们还可以利用指针对char类型的二维数组进行赋值。

这种方法虽然较为复杂，但在一些特定场景下可以发挥出更好的性能和效率。

具体代码如下：```cchar arr[2][3];char *p = &arr[0][0];char temp[] = {'a', 'b', 'c', 'd', 'e', 'f'};for (int i = 0; i < 6; i++) {*(p + i) = temp[i];}```在这种赋值方式中，我们利用指针的特性来对二维数组进行赋值。

C语言指针的初始化和赋值

C语⾔指针的初始化和赋值1、指针的初始化指针初始化时，“=”的右操作数必须为内存中数据的地址，不能够是变量，也不能够直接⽤整型地址值(可是int*p=0;除外，该语句表⽰指针为空)。

此时，*p仅仅是表⽰定义的是个指针变量，并没有间接取值的意思。

⽐如：int a = 25;int *ptr = &a;int b[10];int *point = b;int *p = &b[0];假设：int *p;*p = 7;则编译器（vs2008）会提⽰The variable 'p' is being used without being initialized.即使⽤了未初始化的变量p。

由于p是指向7所在的地址，*p = 7给p所指向的内存赋值，p没有赋值，所以p所指向的内存位置是随机的，没有初始化的。

int k;int *p;p = &k; //给p赋值*p = 7; //给p所指向的内存赋值，即k= 72、指针的赋值int *p;int a;int b[1];p = &a;p = b;指针的赋值，“=”的左操作数能够是*p，也能够是p。

当“=”的左操作数是*p时，改变的是p所指向的地址存放的数据；当“=”的左操作数是p时，改变的是p所指向的地址。

数组的变量名b表⽰该数组的⾸地址，因此p=b；也是正确的同类型的指针赋值：int val1 = 18,val2 = 19;int *p1,*p2;p1 = &val1;p2 = &val2;p1 = p2; //注意啦，p1指向了val2，⽽没有指向val1备注：字符串与指针的初始化和赋值初始化：char *cp = "abcdefg"; //这个初始化过程，是将指针cp指向字符串的⾸地址，⽽并⾮传递字符串的值。

由于，在C语⾔⾥⾯，没有总体处理⼀个字符串的机制赋值：cp = "abcdefg";*cp=”abcdefg” ;//错误！字符串常量传递的是它的⾸地址，不能够通过*cp改动该字符串的值，由于该字符串为常量，⽽它仅仅是简单的将指针指向该字符串常量3、指针常量在C语⾔中没有⼀种内建（built-in）的⽅法去表⽰指针常量，所以当我们使⽤它的时候通常先写成整型常量的形式，然后再通过强制类型转换把它转换成对应的类型，如：int * , double * , char *等。

数组与指针

此外，还可通过算术元运算对指针进行移动，此外，还可通过算术元运算对指针进行移动，来达到引用其他数组元素的目的。其他数组元素的目的。 a[0] p p &a[0] *p a[0] a[1] p+1 p+1 &a[1] *(p+1) a[1] a[2] P+2 p+2 &a[2] *(p+2) a[2] a[3] P+3 p+3 &a[3] *(p+3) a[3] a[4] p+4 p+4 &a[4] *(p+4) a[4]
a[0] a[1] a[2] a[3] a[4]
a
a a+1 a+2 a+3 a+4
a a+1 a+2 a+3 a+4
&a[0] &a[1] &a[2] &a[3] &a[4]
*a *(a+1) *(a+2) *(a+3) *(a+4)
a[0] a[1] a[2] a[3] a[4]
例3: main() { int a[5],*p,i; for(i=0;i<5;i++) scanf(“%d”,a+i); for(i=0;i<5;i++) printf(“%d”,*(a+i)); }
a[1] a[1][0] a[1][1] a[1][2]
此处，的值与的值与a[0]的值相同，但是基类型不同。a是二级的值相同，此处，a的值与的值相同但是基类型不同。是二级指针，是一级指针。指针，a[0]是一级指针。是一级指针 a &a[0][0] a[0] 因此，以下赋值语句是错误的：因此，以下赋值语句是错误的：p=a; a &a[0] a+1 &a[1] a+i &a[i] *(a+i) a[i]

c语言二维数组一行相同赋值

c语言二维数组一行相同赋值1. 引言概述部分的内容可以如下所示：1.1 概述C语言作为一种通用的程序设计语言，在计算机科学领域有着广泛的应用。

而二维数组作为C语言中的重要数据结构之一，也是我们在编写程序时经常会用到的一种数据类型。

二维数组可以理解为一个由多个一维数组组成的表格，每个一维数组称为数组的行，而行内的元素称为数组的列。

通过二维数组，我们可以方便地表示和处理具有多个维度的数据。

比如，在图像处理中，图像可以用二维数组来表示；在矩阵运算中，矩阵可以用二维数组来表示。

然而，有时候我们可能会遇到这样的需求：需要将二维数组的某一行的所有元素都赋予相同的值。

这种需求在一些算法和数据处理过程中很常见。

在本文中，我们将探讨如何在C语言中实现这样的一行相同赋值。

本文将从概述、正文和结论三个部分来展开讨论。

在正文部分中，我们将介绍二维数组的基本概念，以及如何实现一行相同赋值的需求。

在结论部分，我们将对本文进行总结，并探讨可能的应用场景。

通过阅读本文，读者将能够了解C语言中二维数组的基本知识，并学会如何实现一行相同赋值的操作。

下面让我们进入正文部分，详细地探讨二维数组的基本概念以及一行相同赋值的需求。

1.2 文章结构本文将分为引言、正文和结论三个部分，以探讨C语言二维数组中一行相同赋值的需求。

具体结构如下：1. 引言1.1 概述- 简要介绍C语言中的二维数组概念和用途。

1.2 文章结构- 对本文的整体结构进行介绍，包括引言、正文和结论三个部分。

1.3 目的- 阐明本文撰写的目的和意义。

2. 正文2.1 二维数组的基本概念- 详细介绍C语言中二维数组的定义、初始化和访问方法，帮助读者了解基本概念。

2.2 一行相同赋值的需求- 阐述为什么在某些情境下需要将二维数组中的一行赋值为相同的值，并举例说明其实际应用。

3. 结论3.1 总结- 简要总结本文的主要观点和内容。

3.2 可能的应用场景- 探讨一行相同赋值的需求在实际开发中的可能应用场景，帮助读者更好地理解其意义和价值。

c语言指针赋值语句规则

c语言指针赋值语句规则
在C语言中，指针是一种特殊的变量，它存储的是内存地址，而不是实际的值。

指针赋值语句的规则如下：
1. 指针变量必须先初始化，否则编译器会报错。

2. 指针变量只能指向同类型的变量，即一个指向整数的指针不能指向一个浮点数。

3. 指针变量可以指向同类型的数组元素，即一个指向整数的指针可以指向一个整数数组的元素。

4. 指针变量可以指向函数的返回值，即一个指向整数的指针可以指向一个返回整数的函数。

5. 指针变量可以指向指针变量本身，即一个指向指针的指针可以指向另一个指针变量。

6. 指针变量可以指向函数的地址，即一个指向函数的指针可以指向一个函数的入口地址。

7. 指针变量可以指向结构体变量的地址，即一个指向结构体的指针可以指向一个结构体变量的地址。

8. 指针变量可以指向联合体的地址，即一个指向联合体的指针可以指向一个联合体的地址。

9. 指针变量可以指向枚举类型的地址，即一个指向枚举类型的指针可以指向一个枚举类型的地址。

10. 指针变量可以指向函数的地址，即一个指向函数的指针可以指向一个函数的地址。

需要注意的是，在使用指针时，必须确保指针所指向的内存区域是有效的，否则会导致程序崩溃或未定义的行为。

第五章3指针（11--33）

第五章3指针（11--33）⼗⼀指针的运算1、作为⼀种特殊的变量，指针可以进⾏⼀些运算，但并⾮所有的运算都是合法的，指针的运算主要局限在加减算术和其他⼀些为数不多的特殊运算。

2、把a的值5作为地址 0x00000005赋值给*p是发⽣访问冲突。

整数与指针最好不要直接运算。

3、地址的赋值和指针的赋值。

num,p1,p2 他们中⼀个改变，其他的两个都会跟着改变4、 a被编译器解析为数组的⾸地址通过下标循环进⾏遍历通过指针循环进⾏遍历5、通过dll注⼊的⽅式修改另⼀个进程的数据通过定义并初始化⼆级指针p,使其改变另⼀个程序的指针p的指向，从⽽改变它的值。

外挂⼯具：cheat engine注意不会实时刷新⼗⼆指针的算数运算1、使⽤递增/递减运算符（++ 和 --）将指针递增或递减指针++就是按照指针类型的⼤⼩，前进⼀个类型的⼤⼩，int,前进四个字节指针 ++ 和 -- 只有在数组的内部才有意义。

2、指针++ 就是指针每次向前移动sizeof(指针类型)个字节通过指针循环的⽅式初始化数组a的每⼀个元素（从头到尾扫描数组）（注：格式控制符“%p”中的p是pointer（指针）的缩写。

指针的值是语⾔实现（编译程序）相关的，但⼏乎所有实现中，指针的值都是⼀个表⽰地址空间中某个存储器单元的整数。

printf函数族中对于%p⼀般以⼗六进制整数⽅式输出指针的值，附加前缀0x。

）3、指针加上2,在数组内部等价于向后移动两个元素的⼤⼩指针减去3，等价于数组内部，向前移动3个元素的⼤⼩此时此刻，就会打印出 3 5 24、指针的加减法在⾮数组内部没有任何意义，⽽且很容易越界报错⼀个exe不能读写其他exe进程的内存。

⼗三指针之间的⽐较1、对两个毫⽆关联的指针⽐较⼤⼩是没有意义的，因为指针只代表了“位置”这么⼀个信息，但是，如果两个指针所指向的元素位于同⼀个数组（或同⼀块动态申请的内存中），指针的⼤⼩⽐较反映了元素在数组中的先后关系。

二维数组指针定义

二维数组指针定义
二维数组指针是指指向二维数组的指针，它指向一个包含N行M列元素的数组，记为A[N][M]。

其表现形式可以装换为A[N]指数组对象的类型（元素类型）
是M个元素的数组。

可以将由二维数组指针指向的数组看作是一个特殊的一维数组，长度为N*M，元素以M为单位连续存储在内存中，并使用下标运算访问内存中相应位置的数据元素。

与普通指针不同，二维数组指针不仅可以引用某个元素对象，而且可以指定某行或某列。

上述变异反映了二维数组指针运用广泛，无论是在连续内存块中分配了二维数组空间还是在分配非连续内存空间中，指针依然能够有效的指向特定的行/
列信息，因此尤其适用于涉及二维数据操作的编程。

因此，二维数组指针有效地解决了二维数据操作中的一系列地址计算问题，比如使用A[I][J]访问元素，若按普通指针方式访问，就需要重复进行大量的乘法和
加法运算，同时也要保证内存连续的要求。

而使用二维数组指针，则可以减少内存占用，节省编程时间，以及提高运行效率。

另外，二维数组指针还可以用于构造类的设计，类的设计有助于程序的独立性，相对容易被复用。

外部接口定义可以支持与用户层面的访问，使得实现方便，更迅速地处理临时数据。

因此，本文综合总结介绍了二维数组指针：它指向一个二维数组，可以用来根据特定索引进行访问；它有助于构造类，实现程序灵活设计与可复用性；它可以让使用者在处理二维数据时减少内存损耗，同时降低访问难度和提高访问性能。

总而言之，二维数组指针的应用可以帮助我们实现更好的编程效率。

指针与数组

3．通过一个行指针变量引用二维数组的元素
定义一个由m个元素组成的一维数组的指针变量的一般形式：
类型标识符 (*指针变量名)[m];
注意：*p两侧的圆括号不可缺少。例如：假若有语句 int a[2][3], (*p)[3]; p=a;
则：⑴ p是一个指向由3个整型元素组成的一维数组的指针变量。
方法ain() { int a[10]={54,65,8,2,3,56,8,21,57,98},i;
for(printf("\n"),i=0;i<10;i++) printf("%4d",*(a+i)); }
方法三：用指针变量指向数组元素
main() { int a[10]={54,65,8,2,3,56,8,21,57,98},*p,i;
⑵ p指向a数组，p+1指向数组a的下一行首地址，a和p的基类型相同，则a数组中任意元素a[i][j]还可以如下表示： *(p[i]+j) 、*(*(p+i)+j) 、(*(p+i))[j] 、p[i][j]
例：使用行指针变量访问数组元素。
main() {
float fa[5][10], (*pf)[10]=fa; int i,j; for(i=0; i<5; i++)
C语言程序设计
指针与数组
1.1 一维数组的指针
数组的指针：是数组的起始地址。
数组元素的指针：是数组元素的地址。当指针变量指向数组或数组元素时，它就是指向数组的指针变量。
C规定： ⑴数组名代表数组的首地址（起始地址），
也就是第一个元素的地址。
⑵当指针变量p指向数组时，p+1指向数组的下一个元素。假设一个整型元素占两个字节，p+1是使p的地址加2个字节。

c语言指针的用法

c语言指针的用法c语言是一种高级编程语言，它可以直接操作内存中的数据。

指针是c语言中一种特殊的变量，它可以存储另一个变量的地址，也就是内存中的位置。

通过指针，我们可以间接地访问或修改内存中的数据，从而实现更高效和灵活的编程。

本文将介绍c语言指针的基本概念、定义和初始化、运算和应用，以及一些常见的错误和注意事项。

希望本文能够帮助你掌握c语言指针的用法，提高你的编程水平。

指针的基本概念指针是一种数据类型，它可以存储一个地址值，也就是内存中某个位置的编号。

每个变量在内存中都有一个唯一的地址，我们可以用指针来记录这个地址，然后通过这个地址来访问或修改变量的值。

例如，假设有一个整型变量a，它的值为10，它在内存中的地址为1000（为了简化，我们假设地址是十进制数）。

我们可以定义一个指向整型的指针p，并把a的地址赋给p，如下所示：int a =10; // 定义一个整型变量a，赋值为10int*p; // 定义一个指向整型的指针pp =&a; // 把a的地址赋给p这里，&a表示取a的地址，也就是1000。

p = &a表示把1000赋给p，也就是让p指向a。

从图中可以看出，p和a是两个不同的变量，它们占用不同的内存空间。

p存储了a的地址，也就是1000。

我们可以通过p 来间接地访问或修改a的值。

指针的定义和初始化指针是一种数据类型，它需要在使用前进行定义和初始化。

定义指针时，需要指定它所指向的变量的类型。

初始化指针时，需要给它赋一个有效的地址值。

定义指针的一般格式为：type *pointer_name;其中，type表示指针所指向的变量的类型，如int、char、float等；pointer_name表示指针的名称，如p、q、ptr等；*表示这是一个指针类型。

例如：int*p; // 定义一个指向整型的指针pchar*q; // 定义一个指向字符型的指针qfloat*ptr; // 定义一个指向浮点型的指针ptr注意，在定义多个指针时，每个指针前都要加*号，不能省略。

指针与数组

#include <stdio.h>
int main()
{ int a[6],i,s,*p;
printf("Please input data:\n");
for(i=0; i<6; i++ )
scanf("%d", &a[i] );
s=0;
for(p=a; p<a+6; p++) s+=*p ;
printf(“s=%d\n”,s);
8
指针与数组
❖指针运算：
指针类型的数据，除了间接引运算、赋值运算 p 2000
等操作外，当指针指向数组时，指针可以做
加减整数、指针相减及指针比较运算。
▪ 1．指针与整数的加、减运算
• 如果指针p是指向数组中的某个元素，加
p+3 2012
上整数n后，新指针p+n指向后续的第n个
a数组
1 2 3 4 5
a[0] a[1] a[2] a[3]
a[4]
元素。
a[5]
▪ 2．指针相减运算
a[6]
• 两个指向同个数组的同类型指针作相减运
a[7]
算，其绝对值表示它们之间相隔的元素数目。
p+92036
a[8] a[9]
▪ 3．指针之间作关系运算
• 两个相同类型指针可作关系运算比较指针
大小。例8.5程序循环控制是通过 p<a+6
– 行指针a+2，转化为元素指针*(a+2)，指向第3行第一个元素,即 a[2][0]。
– 行指针a+i，转化为元素指针*(a+i)+j，指向第i+1行第j+1一个元素, 即a[i][j]。

二维字符串数组的赋值

二维字符串数组的赋值1. 介绍在计算机编程中，数组是一种常见的数据结构，用于存储多个相同类型的元素。

数组可以是一维的，也可以是多维的，例如二维数组。

二维数组是由多个一维数组组成的表格形式的数据结构。

赋值是将一个值或者一个表达式的结果存储到变量或者数组中的过程。

对于二维字符串数组的赋值，我们需要考虑每个元素的位置以及对应的值。

本文将深入探讨二维字符串数组的赋值过程，包括如何创建和初始化二维字符串数组、如何遍历和访问数组元素，以及不同情况下的赋值方法。

2. 创建和初始化二维字符串数组在开始赋值之前，我们需要首先创建和初始化二维字符串数组。

下面是创建和初始化二维字符串数组的几种常见方法：2.1 方法一：直接初始化可以在声明数组的同时直接给数组赋初值。

例如：String[][] array = {{"apple", "banana", "cherry"}, {"dog", "cat", "rabbit"}};上述代码创建了一个二维字符串数组，包含两个一维数组。

每个一维数组包含三个字符串元素。

2.2 方法二：分步初始化也可以先声明数组，再逐个给数组元素赋值。

例如：String[][] array = new String[2][3];array[0][0] = "apple";array[0][1] = "banana";array[0][2] = "cherry";array[1][0] = "dog";array[1][1] = "cat";array[1][2] = "rabbit";上述代码首先声明了一个二维字符串数组，然后逐个给数组元素赋值。

2.3 方法三：使用循环初始化如果数组比较大，手动逐个赋值可能会比较繁琐。

C语言_指针变量的赋值与运算，很详细

C语⾔_指针变量的赋值与运算，很详细指针变量的赋值指针变量同普通变量⼀样，使⽤之前不仅要定义说明，⽽且必须赋予具体的值。

未经赋值的指针变量不能使⽤，否则将造成系统混乱，甚⾄死机。

指针变量的赋值只能赋予地址，决不能赋予任何其它数据，否则将引起错误。

在Ｃ语⾔中，变量的地址是由编译系统分配的，对⽤户完全透明，⽤户不知道变量的具体地址。

Ｃ语⾔中提供了地址运算符&来表⽰变量的地址。

其⼀般形式为： & 变量名；如&a变⽰变量a 的地址，&b表⽰变量b的地址。

变量本⾝必须预先说明。

设有指向整型变量的指针变量p，如要把整型变量a 的地址赋予p可以有以下两种⽅式：(1)指针变量初始化的⽅法 int a;int *p=&a;(2)赋值语句的⽅法 int a;int *p;p=&a;不允许把⼀个数赋予指针变量，故下⾯的赋值是错误的： int *p;p=1000; 被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是错误的。

指针变量的运算指针变量可以进⾏某些运算，但其运算的种类是有限的。

它只能进⾏赋值运算和部分算术运算及关系运算。

指针运算符1.取地址运算符& 取地址运算符&是单⽬运算符，其结合性为⾃右⾄左，其功能是取变量的地址。

2.取内容运算符* 取内容运算符*是单⽬运算符，其结合性为⾃右⾄左，⽤来表⽰指针变量所指的变量。

在*运算符之后跟的变量必须是指针变量。

需要注意的是指针运算符*和指针变量说明中的指针说明符* 不是⼀回事。

在指针变量说明中，“*”是类型说明符，表⽰其后的变量是指针类型。

⽽表达式中出现的“*”则是⼀个运算符⽤以表⽰指针变量所指的变量。

main(){int a=5,*p=&a;printf ("%d",*p);}......//表⽰指针变量p取得了整型变量a的地址。

本语句表⽰输出变量a的值。

赋值运算指针变量的赋值运算有以下⼏种形式：1：指针变量初始化赋值。

指针二维数组的各种表示

指针二维数组的各种表示指针和数组都是C语言中重要的数据类型，二者的结合使用可以大大增强程序的灵活性和可读性。

其中，指针二维数组是指一个指向指针类型的一维数组，其中每个元素都指向一个指针类型的一维数组，这样就构成了一个二维数组。

指针二维数组的各种表示如下：1. 数组名作为指针使用当我们定义一个二维数组a时，a本身是一个指向a[0]的指针，它可以指向a数组的第一个元素。

因此，我们只需要使用a[i]表示第i行，a[i][j]表示第i行第j列即可。

这种表示方法简单明了，可以直接访问二维数组中的元素，但是无法改变指向数组的指针。

2. 指针数组指针数组是一个一维数组，每个元素都是指向一个一维数组的指针。

定义一个指针数组时，需要指定它的类型，例如int *a[]，表示a是一个指向整型数组的指针数组。

我们可以使用a[i]表示指针数组的第i个元素，使用a[i][j]表示第i个指针所指向的整型数组的第j个元素。

这种表示方法可以在一定程度上改变指向数组的指针，但需要额外的内存空间存储指针数组。

3. 指向二维数组的指针我们也可以定义一个指向二维数组的指针，例如int (*p)[n]，表示p是一个指向有n列的一维整型数组的指针。

我们可以使用p[i][j]表示第i 行第j列的元素。

这种表示方法可以更灵活地改变指向数组的指针，但是需要使用指针和指针运算符来访问数组元素。

4. 指针的指针我们还可以使用指针的指针来表示二维数组。

指针的指针是一个指向指针的指针，例如int **a，表示a是一个指向整型指针的指针。

我们可以使用a[i][j]表示第i行第j列的元素。

这种表示方法可以更加灵活地改变指向数组的指针，但需要使用两个指针来访问元素，增加了内存和时间的开销。

综上所述，指针二维数组有多种表示方法，每种方法都有各自的特点和适用场景。

根据程序的需要，可以选择最合适的表示方法来实现二维数组的访问和操作。

c语言数组之间的赋值

c语言数组之间的赋值C语言是一门非常重要的编程语言，它在计算机领域中有着广泛的应用。

在C语言中，数组是一种非常重要的数据类型，它可以用来存储一组相同类型的数据。

数组之间的赋值也是一种常见的操作，本文将介绍如何在C语言中进行数组之间的赋值。

1. 数组的定义在C语言中，数组是一种由相同类型的元素组成的集合。

数组的定义格式如下：type array_name[array_size];其中，type表示数组元素的类型，array_name表示数组的名字，array_size表示数组的大小。

例如，下面的代码定义了一个整型数组a，它包含了5个元素：int a[5];2. 数组之间的赋值在C语言中，可以通过一个数组向另一个数组赋值。

数组之间的赋值可以使用循环语句来实现。

下面是一个简单的例子，它演示了如何将一个数组的值赋给另一个数组：#include <stdio.h>int main(){int a[5] = {1, 2, 3, 4, 5};int b[5];int i;for(i = 0; i < 5; i++){b[i] = a[i];}for(i = 0; i < 5; i++){printf("%d ", b[i]);}return 0;}在上面的代码中，首先定义了一个整型数组a，它包含了5个元素。

然后定义了另一个整型数组b，并使用循环语句将数组a的值赋给数组b。

最后，使用循环语句输出数组b的值。

3. 多维数组之间的赋值在C语言中，还可以使用一个多维数组向另一个多维数组赋值。

多维数组之间的赋值也可以使用循环语句来实现。

下面是一个简单的例子，它演示了如何将一个多维数组的值赋给另一个多维数组：#include <stdio.h>int main(){int a[2][3] = {{1, 2, 3}, {4, 5, 6}};int b[2][3];int i, j;for(i = 0; i < 2; i++){for(j = 0; j < 3; j++){b[i][j] = a[i][j];}}for(i = 0; i < 2; i++){for(j = 0; j < 3; j++){printf("%d ", b[i][j]);}printf("\n");}return 0;}在上面的代码中，首先定义了一个2行3列的整型数组a，并将它的值初始化。

CC++——二维数组与指针、指针数组、数组指针（行指针）、二级指针的用法

CC++——⼆维数组与指针、指针数组、数组指针（⾏指针）、⼆级指针的⽤法1. ⼆维数组和指针要⽤指针处理⼆维数组，⾸先要解决从存储的⾓度对⼆维数组的认识问题。

我们知道，⼀个⼆维数组在计算机中存储时，是按照先⾏后列的顺序依次存储的，当把每⼀⾏看作⼀个整体，即视为⼀个⼤的数组元素时，这个存储的⼆维数组也就变成了⼀个⼀维数组了。

⽽每个⼤数组元素对应⼆维数组的⼀⾏，我们就称之为⾏数组元素，显然每个⾏数组元素都是⼀个⼀维数组下⾯我们讨论指针和⼆维数组元素的对应关系，清楚了⼆者之间的关系，就能⽤指针处理⼆维数组了。

设p是指向⼆维数组a[m][n]的指针变量，则有：int* p=a[0];//此时P是指向⼀维数组的指针。

P++后，p指向 a[0][1]。

如果定义int (*p1)[n];p1=a;p1++后，p1指向a[1][0];则p+j将指向a[0]数组中的元素a[0][j]。

由于a[0]、a[1]┅a[M-1]等各个⾏数组依次连续存储，则对于a数组中的任⼀元素a[i][j]，指针的⼀般形式如下：p+i*N+j 相应的如果⽤p1来表⽰，则为*(p1+i)+j元素a[i][j]相应的指针表⽰为：*( p+i*N+j) 相应的如果⽤p1来表⽰，则为*(*(p1+i)+j)同样，a[i][j]也可使⽤指针下标法表⽰，如下：p[i*N+j]例如，有如下定义：int a[3][4]={{10,20,30,40,},{50,60,70,80},{90,91,92,93}};则数组a有3个元素，分别为a[0]、a[1]、a[2]。

⽽每个元素都是⼀个⼀维数组，各包含4个元素，如a[1]的4个元素是a[1][0]、a[1][1]、a[1]2]、a[1][3]。

若有：int *p=a[0];则数组a的元素a[1][2]对应的指针为：p+1*4+2元素a[1][2]也就可以表⽰为：*( p+1*4+2)⽤下标表⽰法，a[1][2]表⽰为：p[1*4+2]特别说明：对上述⼆维数组a，虽然a[0]、a都是数组⾸地址，但⼆者指向的对象不同，a[0]是⼀维数组的名字，它指向的是a[0]数组的⾸元素，对其进⾏“*”运算，得到的是⼀个数组元素值，即a[0]数组⾸元素值，因此，*a[0]与a[0][0]是同⼀个值；⽽a是⼀个⼆维数组的名字，它指向的是它所属元素的⾸元素，它的每⼀个元素都是⼀个⾏数组，因此，它的指针移动单位是“⾏”，所以a+i指向的是第i个⾏数组，即指向a[i]。

关于二维数组地址和指针之间的赋值

在开发工业以太网项目的时候经常遇到一些小细节问题，在建立数据报进行传输的过程中传递txbuf缓冲区的地址的时候就遇到类似下面的问题。

一．简单说明1定义一个2X3的int型的二维数组int array[2][3];并且给这个二维数组赋值1,2,3,4,5,6；array[0][0]=1array[0][1]=2array[0][2]=3array[1][0]=4array[1][1]=5array[1][2]=6输出结果1 2 34 5 6array[0]表示第一行的首地址，也就是第一行第一个数的地址，也就是&array[0][0] So array[0]==&array[0][0]；其实&array[0]还==array[0]==&array[0][0]，都表示第一行的首地址。

array[1]是第二行的首地址，也就是第二行第一个数的地址，也就是&array[1][0]so array[1]=&array[1][0];试试&array[1]还==array[1]==&array[1][0]定义一个指针变量int *p;将第一行的首地址赋给p有3种方式。

1. p=array[0];2. p=&array[0];3. p=&array[0][0];p[0]就等同于array[0][0],也就是p[0]==1;(为了形象记忆，可以用替换的角度去记忆和理解。

因为之前说过p=array[0], so，p[0]就把p换成array[0]再加上[0]就是arary[0][0])p[1]等于array[0][1]等于2p[2]等于array[0][2]等于3同理，将第二行的首地址赋给p也有三种方式：3. p=array[1];4. p=&array[1];5. p=&array[1][0];p[0]等于array[1][0]等于4p[1]等于array[1][1]等于5p[2]等于array[1][2]等于6。

二维数组赋值

二维数组赋值
一维数组赋值是将一个变量赋值给一个索引值，一般使用下标进行访问。

而二维数组赋值就是将一个变量赋值给两个索引值。

也就是说，在 XY 坐标系中，它使用两个下标来指代一个坐标点。

具体来说，可以使用括号将两个下标用空格隔开，而两个下标都分别指向一个数组，最后把变量赋值给两个数组。

比如例子，定义一个二维数组 int a[2][2] ，用于保存矩阵的两个维度的值。

可以使用如下方式赋值：
a[0][0] = 1 ; // 保存矩阵的第一个值
a[0][1] = 2 ; // 保存矩阵的第二个值
a[1][0] = 3 ; // 保存矩阵的第三个值
a[1][1] = 4 ; // 保存矩阵的第四个值
可以看到，这里使用了四个赋值语句，分别把四个值（1、2、3、4）保存到了二维数组a中，形成了一个矩阵。

同样可以使用嵌套循环给二维数组赋值：
for (int i=0; i<2Y; i++)
{
for (int j=0; j<2; j++)
{
a[i][j] = (i+1)*(j+1);
}
}
可以看到，这里使用两个循环，循环过程中定义了两个变量i和j，分别指向二维数组a中的行和列，最后把（i+1）*（j+1）的值赋值给a[i][j]，形成了矩阵。

实际上，用于二维数组赋值的方式，可以用来保存任意维度的数据，只要定义的数组长度足够大就可以了。

c语言指针赋值方式

总结：在C语言中，指针赋值方式有以下几种：
直接赋值法：将一个指针变量的地址赋值给另一个指针变量。

间接赋值法：将一个指针变量的地址赋值给一个指向该地址的指针变量的指针变量。

使用解引用运算符赋值法：将一个指针变量的地址赋值给一个指向该地址的指针变量的指针变量。

使用解引用运算符间接赋值法：将一个指针变量的地址赋值给一个指向该地址的指针变量的指针变量。

需要注意的是，在使用间接赋值法时，要确保新指针变量指向的地址是正确的。

否则可能会导致程序出现错误。

指针的赋值和使用

指针的赋值和使⽤
更多来⾃：
3.9.3 指针的赋值和使⽤
在得到⼀个指针变量之后，指针变量的值还是⼀个随机值。

这个值可能是内存中⽆关紧要的数据，也可能是重要的数据或者程序代码，如果直接使⽤是很危险的，所以在使⽤指针之前，必须对其进⾏赋值，将其指向某个有意义的数据或代码。

对指针变量进⾏赋值的语法格式如下：
指针变量 = 内存地址;
可以看到，对指针变量的赋值，实际上就是将这个指针指向某⼀内存地址，⽽这个内存地址上存放的就是这个指针想要指向的数据。

通常我们⽤⼀个变量来保存数据，那么该如何⽅便地得到⼀个变量在内存中的地址呢？反过来，如果知道⼀个指针，⼜如何取出存放在其中的数据呢？为了解决这两个问题，C++提供了两个与内存地址相关的运算符——“&”和“*”。

1. “&”运算符
“&”称为取地址运算符，如果把它放在⼀个变量的前⾯，则可以得到该变量在内存中存放的地址。

例如：
// 定义⼀个整型变量
int N = 703;
// 取得整型变量的地址并将其赋值给整型指针
int*pN = &N;
通过“&”运算符可以取得N这个整型变量的内存地址，然后将其赋值给指针pN，也就是将指针pN指向N这个整数数据，如图3-7所⽰。

图3-7 指针和指针所指向的数据。

如何给地址赋值？（转）

如何给地址赋值？（转）1.⼀种直观的⽅法假设现在需要往内存0x12ff7c地址上存⼊⼀个整型数0x100。

我们怎么才能做到呢？我们知道可以通过⼀个指针向其指向的内存地址写⼊数据，那么这⾥的内存地址0x12ff7c其本质不就是⼀个指针嘛。

所以我们可以⽤下⾯的⽅法：1 2int*p = (int*)0x12ff7c; *p = 0x100;需要注意的是将地址0x12ff7c赋值给指针变量p的时候必须强制转换。

1.1 为什么在此处，我们敢往0x12ff7c这个地址赋值呢？⾄于这⾥为什么选择内存地址0x12ff7c，⽽不选择别的地址，⽐如0xff00等。

这仅仅是为了⽅便在Visual C++ 6.0上测试⽽已。

如果你选择0xff00，也许在执⾏*p = 0x100;这条语句的时候，编译器会报告⼀个内存访问的错误，因为地址0xff00处的内存你可能并没有权⼒去访问。

既然这样，我们怎么知道⼀个内存地址是可以合法的被访问呢？也就是说你怎么知道地址0x12ff7c处的内存是可以被访问的呢？其实这很简单，我们可以先定义⼀个变量i，⽐如：1int i = 0;变量i所处的内存肯定是可以被访问的。

然后在编译器的watch窗⼝上观察&i的值不就知道其内存地址了么？这⾥我得到的地址是0x12ff7c，仅此⽽已（不同的编译器可能每次给变量i分配的内存地址不⼀样，⽽刚好Visual C++ 6.0每次都⼀样）。

你完全可以给任意⼀个可以被合法访问的地址赋值。

得到这个地址后再把“int i = 0;”这句代码删除。

⼀切“罪证”销毁得⼀⼲⼆净，简直是做得天⾐⽆缝。

2.另⼀个⽅法除了这样就没有别的办法了吗？未必。

我们甚⾄可以直接这么写代码：1*(int*)0x12ff7c= 0x100;这⾏代码其实和上⾯的两⾏代码没有本质的区别。

先将地址0x12ff7c强制转换，告诉编译器这个地址上将存储⼀个int类型的数据；然后通过钥匙“*”向这块内存写⼊⼀个数据。