【C++】二维数组的行指针和列指针

C语言之指针用法 指针的用法 阅读详情
AI摘要

本文详细介绍了C++中一维数组和指针的对应关系,包括指针声明与初始化,以及二维数组的行指针、列指针概念及其应用实例。通过实例演示了如何使用行指针和列指针遍历和操作二维数组,并提供了相关代码验证。

在C++中,数组与指针有密切的关系。任何通过数组和下标实现的表达式可等价地通过指针和偏移量实现。下面首先介绍一维数组与指针的关系,之后介绍二维数组的行指针和列指针。

1.一维数组和指针

定义一个长度为3的一维数组a:

int a[3] = {1, 2, 3};

假设其首元素地址为0x9F36FAE0,则数组元素在内存中的示意图如下图所示:

一维数组内存示意图

1.1 指向数组元素的指针

指向数组元素的指针声明和初始化方式如下:

int* p = a;  // 等价于int* p = &a[0];

这里声明了一个指向数组a的首元素的指针p。

由于在C++中数组名就是数组首元素的地址,因此可以直接使用数组名来初始化指针,也可以显式地取数组元素的地址(如&a[0])。

一维数组-指向数组元素的指针

对于数组a和指向其首元素的指针p,有以下等价形式:

含义等价形式类型值
首元素的值a[0]、*a、p[0]、*pint1
首元素的地址&a[0]、a、&p[0]、pint*0x9F36FAE0
第i个元素的值a[i]、*(a+i)、p[i]、*(p+i)int3 (i = 2)
第i个元素的地址&a[i]、a+i、&p[i]、p+iint*0x9F36FAE8 (i = 2)

★根据C++地址算术运算的定义,无论a是数组名还是指针,都有

  • a[i]等价于*(a+i)
  • &a[i]等价于a+i

1.2 指向数组的指针

指向数组的指针声明和初始化方式如下:

int (*q)[3] = &a;

这里声明了一个指向数组a 本身的指针q,因此*q等价于a。

注意:这里的圆括号不能省略,否则int *q[3]声明的是“有3个元素的整型指针数组”,而不是“指向有3个元素的整型数组的指针”。

一维数组-指向数组的指针

对于数组a和指向其本身的指针q,有以下等价形式:

含义等价形式类型值
首元素的值a[0]、*a、(*q)[0]、**qint1
首元素的地址&a[0]、a、&(*q)[0]、*qint*0x9F36FAE0
第i个元素的值a[i]、*(a+i)、(*q)[i]、*(*q+i)int3 (i = 2)
第i个元素的地址&a[i]、a+i、&(*q)[i]、*q+iint*0x9F36FAE8 (i = 2)
数组的地址&a、qint(*)[3]0x9F36FAE0

注意:&a在数值上等于a,但二者的类型不同,如下表所示:

指针指针类型元素类型sizeof元素指针值
aint[3]int40x9F36FAE0
a+1int[3]int40x9F36FAE4
pint*int40x9F36FAE0
p+1int*int40x9F36FAE4
&aint(*)[3]int[3]120x9F36FAE0
&a+1int(*)[3]int[3]120x9F36FAEC
qint(*)[3]int[3]120x9F36FAE0
q+1int(*)[3]int[3]120x9F36FAEC

&a和q是指向数组的指针,因此&a+1和q+1直接到达数组末尾的下一个位置。

1.3 验证代码

#include <cstdio>

using namespace std;

int main() {
    int a[3] = {1, 2, 3};
    int* p = a;
    int (*q)[3] = &a;

    printf("第i个元素的值:\n");
    printf("%s %10s %10s %10s %10s %10s %10s\n", "i", "a[i]", "*(a+i)", "p[i]", "*(p+i)", "(*q)[i]", "*(*q+i)");
    for (int i = 0; i < 3; ++i)
        printf("%d %10d %10d %10d %10d %10d %10d\n", i, a[i], *(a + i), p[i], *(p + i), (*q)[i], *(*q + i));
    putchar('\n');

    printf("第i个元素的地址:\n");
    printf("%s %10s %10s %10s %10s %10s %10s\n", "i", "&a[i]", "a+i", "&p[i]", "p+i", "&(*q)[i]", "*q+i");
    for (int i = 0; i < 3; ++i)
        printf("%d %10p %10p %10p %10p %10p %10p\n", i, &a[i], a + i, &p[i], p + i, &(*q)[i], *q + i);
    putchar('\n');

    printf("指针的值:\n");
    printf("%10s %10s %10s\n", "指针", "类型", "值");
    printf("%10s %10s %10p\n", "a", "int[3]", a);
    printf("%10s %10s %10p\n", "a+1", "int[3]", a + 1);
    printf("%10s %10s %10p\n", "p", "int*", p);
    printf("%10s %10s %10p\n", "p+1", "int*", p + 1);
    printf("%10s %10s %10p\n", "&a", "int(*)[3]", &a);
    printf("%10s %10s %10p\n", "&a+1", "int(*)[3]", &a + 1);
    printf("%10s %10s %10p\n", "q", "int(*)[3]", q);
    printf("%10s %10s %10p\n", "q+1", "int(*)[3]", q + 1);
    return 0;
}

输出如下(指针的具体值会随每次运行变化):

第i个元素的值:
i       a[i]     *(a+i)       p[i]     *(p+i)    (*q)[i]    *(*q+i)
0          1          1          1          1          1          1
1          2          2          2          2          2          2
2          3          3          3          3          3          3

第i个元素的地址:
i      &a[i]        a+i      &p[i]        p+i   &(*q)[i]       *q+i
0   9F36FAE0   9F36FAE0   9F36FAE0   9F36FAE0   9F36FAE0   9F36FAE0
1   9F36FAE4   9F36FAE4   9F36FAE4   9F36FAE4   9F36FAE4   9F36FAE4
2   9F36FAE8   9F36FAE8   9F36FAE8   9F36FAE8   9F36FAE8   9F36FAE8

指针的值:
      指针       类型         值
         a     int[3]   9F36FAE0
       a+1     int[3]   9F36FAE4
         p       int*   9F36FAE0
       p+1       int*   9F36FAE4
        &a  int(*)[3]   9F36FAE0
      &a+1  int(*)[3]   9F36FAEC
         q  int(*)[3]   9F36FAE0
       q+1  int(*)[3]   9F36FAEC

2.二维数组和指针

定义一个大小为2×3的二维数组a:

int a[2][3] = { {1, 2, 3}, {4, 5, 6} };

假设其首元素地址为0x19AFFC40。

二维数组在概念上可理解为矩阵:

二维数组矩阵示意图

但二维数组在内存中的实际存储形式是按行的顺序依次存储,如下图所示:

二维数组内存示意图

可以看出,二维数组在内存中是以类似于一维数组的形式存储的,元素a[i][j]的偏移量可使用公式i*列数+j计算。

虽然二维数组并不是以矩阵的形式存储的,但二维数组的每一行(每个元素)就是一个一维数组,在这一点上与矩阵的概念是一致的。

2.1 地址运算

由于二维数组就是一维数组的数组,元素类型是一维数组,数组名仍然是首元素的地址。在这里“首元素”就是二维数组的首行,因此a是首行的地址。使用数组名a可进行如下的地址运算。

2.1.1 行

含义等价形式类型数组元素值
首行a[0]、*aint[3]{1, 2, 3}0x19AFFC40
首行的地址&a[0]、aint(*)[3]0x19AFFC40
第i行a[i]、*(a+i)int[3]{4, 5, 6} (i = 1)0x19AFFC4C (i = 1)
第i行的地址&a[i]、a+iint(*)[3]0x19AFFC4C (i = 1)

由此可以看出,即使数组元素的类型变成了一维数组,1.1节最后的结论仍然成立。

2.1.2 数组元素

含义等价形式类型值
首行首列元素的值a[0][0]、*a[0]、(*a)[0]、**aint1
首行首列元素的地址&a[0][0]、a[0]、*aint*0x19AFFC40
第i行首列元素的值a[i][0]、*a[i]、(*(a+i))[0]、**(a+i)int4 (i = 1)
第i行首列元素的地址&a[i][0]、a[i]、*(a+i)int*0x19AFFC4C (i = 1)
第i行第j列元素的值a[i][j]、*(a[i]+j)、(*(a+i))[j]、*(*(a+i)+j)int6 (i = 1, j = 2)
第i行第j列元素的地址&a[i][j]、a[i]+j、*(a+i)+jint*0x19AFFC54 (i = 1, j = 2)

注意:&a[0][0]、a[0]、&a[0]、a和&a(上面未出现)在数值上均相等,但类型不同,如下表所示:

指针指针类型元素类型sizeof元素指针值
&a[0][0]int*int40x19AFFC40
&a[0][0]+1int*int40x19AFFC44
a[0]int[3]int40x19AFFC40
a[0]+1int[3]int40x19AFFC44
&a[0]int(*)[3]int120x19AFFC40
&a[0]+1int(*)[3]int120x19AFFC4C
aint[2][3]int[3]120x19AFFC40
a+1int[2][3]int[3]120x19AFFC4C
&aint(*)[2][3]int[2][3]240x19AFFC40
&a+1int(*)[2][3]int[2][3]240x19AFFC58

2.2 行指针

二维数组行指针的声明和初始化方式如下:

int (*q)[3] = a;  // 等价于int (*q)[3] = &a[0];

这里声明了一个指向二维数组a首行的指针q,因此*q等价于a[0],如下图所示:

二维数组-行指针

从语法上可以看出,行指针本质上就是指向一维数组的指针。二维数组a的首行a[0]就是一个长度为3的一维数组,因此可以使用其地址&a[0]来初始化行指针q。另一方面,因为数组名就是首元素的地址,因此a等价于&a[0]。

对于二维数组a和指向其首行的指针q,有以下等价形式:

含义等价形式类型数组元素值
首行a[0]、q[0]、*qint[3]{1, 2, 3}0x19AFFC40
首行的地址&a[0]、a、&q[0]、qint(*)[3]0x19AFFC40
第i行a[i]、q[i]、*(q+i)int[3]{4, 5, 6} (i = 1)0x19AFFC4C (i = 1)
第i行的地址&a[i]、&q[i]、q+iint(*)[3]0x19AFFC4C (i = 1)

与数组元素相关的表达形式这里不再列举,直接将a替换为q即可。

2.3 列指针

二维数组列指针的声明和初始化方式如下:

int* p = &a[0][0];

这里声明了一个指向二维数组a首行首列元素的指针p,如下图所示:

二维数组-列指针

可以看出,列指针就是指向数组元素的普通指针。通过列指针可以将二维数组当作一维数组、利用偏移量计算公式来访问数组元素。

对于二维数组a和指向其首行首列元素的指针p,有以下等价形式:

含义等价形式类型值
首行首列元素的值a[0][0]、p[0]、*pint1
首行首列元素的地址&a[0][0]、&p[0]、pint*0x19AFFC40
第i行首列元素的值a[i][0]、p[i*3]、*(p+i*3)int4 (i = 1)
第i行首列元素的地址&a[i][0]、&p[i*3]、p+i*3int*0x19AFFC4C (i = 1)
第i行第j列元素的值a[i][j]、p[i*3+j]、*(p+i*3+j)int6 (i = 1, j = 2)
第i行第j列元素的地址&a[i][j]、&p[i*3+j]、p+i*3+jint*0x19AFFC54 (i = 1, j = 2)

注:

  • 使用列指针时不存在“行”的概念,因为对于列指针来说,二维数组a相当于长度为6的一维数组。
  • 通过列指针访问元素时(p[i*3+j])用到了列数3,而通过行指针或者数组名+下标访问元素时(a[i][j])却不需要,好像编译器能够“自动”知道列数。这是因为数组的声明类型int a[2][3]中包含了列数信息——这就是为什么在定义二维数组或者声明函数参数时可以省略行数,但必须指定列数的原因,即可以声明为int a[][3],但不能是int a[][]。

2.4 验证代码

#include <cstdio>

using namespace std;

int main() {
    int a[2][3] = { {1, 2, 3}, {4, 5, 6} };
    int (*q)[3] = a;    // 行指针
    int* p = &a[0][0];  // 列指针

    printf("第i行的地址\n");
    printf("%s %10s %10s %10s %10s\n", "i", "&a[i]", "a+i", "&q[i]", "q+i");
    for (int i = 0; i < 2; ++i)
        printf("%d %10p %10p %10p %10p\n", i, &a[i], a + i, &q[i], q + i);
    putchar('\n');

    printf("第i行第j列元素的值\n");
    printf("%s %s %10s %10s %10s %10s\n", "i", "j", "a[i][j]", "*(*(a+i)+j)", "p[i*3+j]", "*(p+i*3+j)");
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 3; ++j)
            printf("%d %d %10d %10d %10d %10d\n", i, j, a[i][j], *(*(a + i) + j), p[i * 3 + j], *(p + i * 3 + j));
    putchar('\n');

    printf("第i行第j列元素的地址\n");
    printf("%s %s %10s %10s %10s %10s\n", "i", "j", "&a[i][j]", "*(a+i)+j", "&p[i*3+j]", "p+i*3+j");
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 3; ++j)
            printf("%d %d %10p %10p %10p %10p\n", i, j, &a[i][j], *(a + i) + j, &p[i * 3 + j], p + i * 3 + j);
    putchar('\n');

    printf("指针的值:\n");
    printf("%10s %15s %10s\n", "指针", "类型", "值");
    printf("%10s %15s %10p\n", "&a[0][0]", "int*", &a[0][0]);
    printf("%10s %15s %10p\n", "&a[0][0]+1", "int*", &a[0][0] + 1);
    printf("%10s %15s %10p\n", "a[0]", "int[3]", a[0]);
    printf("%10s %15s %10p\n", "a[0]+1", "int[3]", a[0] + 1);
    printf("%10s %15s %10p\n", "&a[0]", "int(*)[3]", &a[0]);
    printf("%10s %15s %10p\n", "&a[0]+1", "int(*)[3]", &a[0] + 1);
    printf("%10s %15s %10p\n", "a", "int[2][3]", a);
    printf("%10s %15s %10p\n", "a+1", "int[2][3]", a + 1);
    printf("%10s %15s %10p\n", "&a", "int(*)[2][3]", &a);
    printf("%10s %15s %10p\n", "&a+1", "int(*)[2][3]", &a + 1);
    return 0;
}

输出如下(指针的具体值会随每次运行变化):

第i行的地址
i      &a[i]        a+i      &q[i]        q+i
0   19AFFC40   19AFFC40   19AFFC40   19AFFC40
1   19AFFC4C   19AFFC4C   19AFFC4C   19AFFC4C

第i行第j列元素的值
i j    a[i][j] *(*(a+i)+j)   p[i*3+j] *(p+i*3+j)
0 0          1          1          1          1
0 1          2          2          2          2
0 2          3          3          3          3
1 0          4          4          4          4
1 1          5          5          5          5
1 2          6          6          6          6

第i行第j列元素的地址
i j   &a[i][j]   *(a+i)+j  &p[i*3+j]    p+i*3+j
0 0   19AFFC40   19AFFC40   19AFFC40   19AFFC40
0 1   19AFFC44   19AFFC44   19AFFC44   19AFFC44
0 2   19AFFC48   19AFFC48   19AFFC48   19AFFC48
1 0   19AFFC4C   19AFFC4C   19AFFC4C   19AFFC4C
1 1   19AFFC50   19AFFC50   19AFFC50   19AFFC50
1 2   19AFFC54   19AFFC54   19AFFC54   19AFFC54

指针的值:
      指针            类型         值
  &a[0][0]            int*   19AFFC40
&a[0][0]+1            int*   19AFFC44
      a[0]          int[3]   19AFFC40
    a[0]+1          int[3]   19AFFC44
     &a[0]       int(*)[3]   19AFFC40
   &a[0]+1       int(*)[3]   19AFFC4C
         a       int[2][3]   19AFFC40
       a+1       int[2][3]   19AFFC4C
        &a    int(*)[2][3]   19AFFC40
      &a+1    int(*)[2][3]   19AFFC58

3.n维数组和指针

行指针和列指针的概念可以推广到n维数组:

  • n维数组的行指针就是指向n-1维数组的指针。
  • n维数组的列指针就是指向数组元素的普通指针。

例如:

int a[2][3][4] = {
    { {1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12} },
    { {13, 14, 15, 16}, {17, 18, 19, 20}, {21, 22, 23, 24} }
};
int (*q)[3][4] = a;
int* p = &a[0][0][0];

这段代码声明了一个三维数组a以及指向其“首行”的行指针q和指向其首元素的列指针p,则a[i][j][k]分别等价于q[i][j][k]和p[((i*3)+j)*4+k]。

4.应用

下面的程序分别使用行指针和列指针遍历二维数组,并展示了如何将行指针和列指针传递给函数:

#include <iostream>

using namespace std;

void print_2d_array(int a[][3], int m, int n);
void print_2d_array_row_pointer(int (*q)[3], int m, int n);
void print_2d_array_col_pointer(int* p, int m, int n);

int main() {
    int a[2][3] = { {1, 2, 3}, {4, 5, 6} };
    int (*q)[3] = a;
    int* p = &a[0][0];

    print_2d_array(a, 2, 3);
    print_2d_array_row_pointer(q, 2, 3);
    print_2d_array_col_pointer(p, 2, 3);
    return 0;
}

void print_2d_array(int a[][3], int m, int n) {
    cout << "直接打印二维数组:" << endl;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j)
            cout << a[i][j] << ' ';
        cout << endl;
    }
}

void print_2d_array_row_pointer(int (*q)[3], int m, int n) {
    cout << "使用行指针打印二维数组:" << endl;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j)
            cout << q[i][j] << ' ';
        cout << endl;
    }
}

void print_2d_array_col_pointer(int* p, int m, int n) {
    cout << "使用列指针打印二维数组:" << endl;
    for (int i = 0; i < m; ++i) {
        for (int j = 0; j < n; ++j)
            cout << p[i * n + j] << ' ';
        cout << endl;
    }
}

5.参考

二维数组与指针(详解)

c++二维数组指针详解 int main() { int a[3][4]={{1,2,3,4},{5,6,7,8},{9,10,11,12}}; int *p1; p1=a[0]; //表示数组a第一个元素的地址,相当于p1=&a[0][0] //上面可以这么理解:对于一维数组a[],数组名a是第一个元素a[0]的地址,那么对于二维数组a[][],一维数组名a[0]是它的第一个元素a[0][... 阅读详情

相关推荐

【C++】第6章:(三) 指针和二维数组

文章目录二维数组与指针的关系行指针与列指针(重点)用指针操作二维数组的实例 二维数组与指针的关系 int a[3][4]; 对于二维数组a: a是数组名,包含三个元素,a[0],a[1],a[2] 每个元素a[i],又是一个一维数组,包含4个元素 二维数组具有二级地址的含义 行指针与列指针(重点) 行指针:a[0],a[1],a[2],a[3] 列指针:a[0]+1,a[0]+2,a[1]+1...

vichin_0215 368

二维数组与指针(详解)

一.2维数组 1.二维数组的定义 int a[3][3]; 在这我们定义了一个二维数组,拥有3行3列共9个int型存储空间大小。 2.二维数组的行地址和各个元素地址的表示 int a[3][4]; 对于数组a,我们可以将a[3][4]分为两部分理解a[3]和[4],对于a[3],我们可以看成是一个一维数组,其元素分别为a[0],a[1],a[2],他们分别表示各行所代表的起始地址,而对于[4]...

dddjjjsicnu的博客 7万+

指向二维数组的指针+用typedef定义行指针和数组

指向二维数组的指针指向二维数组的指针行指针用行指针变量输出整个二维数组的元素列指针使用列指针输出二维数组使用列指针找出二维数组中的最大值 指向二维数组的指针 int a[3][4]= { {1,4,2,5}, {5,4,7,6}, {2,8,9,4}, }; 定义一个二维数组:该数组有三行四列。二维数组可以看成特殊的一维数组。数组名a代表数组的起始地址,a[0]代表第一行第一个元素的地址,所以a和a[0]的地址是一样的,但是不能用*a来访问a[0]的内容: a代表第一行的地址,a+1代表第二行的地

Jackey_Song的博客 1579

行指针

行指针一般用于二维数组中,指向每行元素的首地址; 定义形式:int (*p) [5] ; 表示方法:直接在p上偏移就是行,在*p上偏移就是列 #include void main(){     int n[][3] = {10,20,30,40,50,60};     int (*p)[3];     p=n;     cout",""," }  

hongqianshen的博客 5213

C++中二维数组与指针

1 二维数组 C++中所说的多维数组实际上是数组的数组,例如 int ia[3][4] = {{0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9 ,10, 11}}; 此时ia实际上是一个包含3个元素的数组,而每个元素又是一个包含4个整型类型的数组。 2 指向数组的指针 定义指向数组的指针的格式为 类型名 (*标识符) 例如, int (*ip)[4]; 需要...

hou09tian的博客 1304

指向二维数组的指针

每个元素 a[i]又是一个一维数组,包含 4 个元素对二维数组 int a[3][4],有。每个元素 a[i]又是一个一维数组,包含 4 个元素对二维数组 int a[3][4],有。> *(a+i) &a[i][0],表示第 i 行第 0 列元素地址,指向列。> *(a+i) &a[i][0],表示第 i 行第 0 列元素地址,指向列。a 是数组名,包含三个元素 a[0],a[1],a[2]。a 是数组名,包含三个元素 a[0],a[1],a[2]。

Junds0的博客 632

行指针与列指针

比如:数组a[3][3]行指针 a   &a[0];列指针 a[0]  *(a+0);Int  b[4];//b是列地址int  (*p)[3]; //定义一个行指针,此行指针指向一个有三个元素的int类型数组 关于行指针和列指针的两句话:行指针取*变成列指针,列指针再取*变成数组元素;                                数组元素取地址变成列

UnrealEngine4 、Delta3D、OSG 1335

全球半导体设备氧化钇熔射服务行业规模预测:预计未来六年CAGR为7.8%

本文将对“半导体设备氧化钇熔射服务”行业进行深度分析,探讨市场趋势的演变、核心竞争者的战略布局、供应链结构的内外特点、研发创新的最新进展、法规政策环境的适应性调整以及投资机会与风险评估。这一稳健的增长趋势表明半导体设备氧化钇熔射服务在电子行业中的重要性逐渐增强。由于全球对于高效、高精度和可靠的电子解决方案的需求增加,对能够提供这些功能的半导体设备氧化钇熔射服务的需求日益增长。由于半导体设备氧化钇熔射服务主要为就地服务型,其“配送”主要依赖于专业团队和技术设备的及时调配,强调服务的时效性和高质量。

CC1239777的博客 575

如何理解二维数组与指针

一维数组 int a[3]={1,2,3} 赋值:int *p=a 我们有  a[0]==*(a+0)==*a 同样的  a[i]==*(a+i) 对于一维数组可以理解为列指针,因为它的移动是发生在列上的 二维数组:int a[2][3]={{1,2,3},{4,5,6}} 赋值:int (*p)[3]=a 而对于二维数组可以把它理解为行指针 a 表示的是该二维数组的首地址

rihui1hao的专栏 1114

从拆解图看懂空心杯电机:有刷 vs 无刷内部结构全解析(附DIY注意事项)

本文深入解析有刷与无刷空心杯电机的内部结构差异,通过高清拆解图展示关键部件工艺特点,并分享实用的维护技巧和检测方法。重点对比两种电机在效率、寿命和适用场景上的优劣,为DIY爱好者提供详细的注意事项和操作指南。

xgboost6farmer的博客 527

Microchip Studio 7.0 从零开始:下载、安装到首个AVR工程实战

本文为AVR单片机开发新手提供了Microchip Studio 7.0的完整入门指南。从官方下载、避坑安装,到创建首个GCC C工程、编写LED闪烁代码,再到项目配置、仿真调试与程序烧录,手把手带你完成从零到一的实战过程,是掌握AVR开发环境的必备教程。

weixin_29200741的博客 535

c++ 返回二维数组_C的指针(三)指针和二维数组

对于二维数组 array[4][5]. array 应理解为是包含四个元素的数组,每个元素是一个一维数组,它们有五个元素。例:int mat[3][4];数组含义: 数组 mat 包含三个元素:mat[0], mat[1], mat[2] mat 的第一个元素 mat[0] 是包含四个整形变量的数组考虑到数组名代表数组第一个元素的地址mat 是其第一个元素 mat[0] 的地址,即 mat = ...

weixin_39800331的博客 472

【新版系统架构】系统架构设计师教程全篇知识点提炼

信息系统的5个基本功能:输入、存储、处理、输出和控制信息系统的发展:诺兰模型:初始阶段、传播阶段、控制阶段、集成阶段、数据管理阶段、成熟阶段信息系统的分类:传统的信息系统分为:业务(数据)处理系统、管理信息系统(MIS)、决策支持系统(DSS)、专家系统(ES)、办公自动化系统(OAS)等5类信息系统的生命周期:1、产生阶段2、开发阶段(总体规划、系统分析、系统设计、系统实施、系统验收阶段)3、运行阶段4、消亡阶段信息系统建设原则:1、高层管理人员介入原则。

分享技术干货和灵感、推荐新书和好玩的项目、分享Java面试题 1万+

C++行指针:二维数组操作精髓

本文介绍了C++中行指针的概念及其在二维数组处理中的应用。行指针是指向二维数组中某行的指针,声明形式为数据类型(*指针名)[列数],与列指针的区别在于指针算术的行为不同。文章详细阐述了四种二维数组作为函数参数的传递方法:固定列数的行指针方式、动态数组的指针指针法、通用性强的扁平化传递以及类型安全的模板方式。最后对比了各方法的特性,建议现代C++开发中:静态数组优先使用模板方式,动态数组推荐使用vector<vector<T>>,需要高性能时可考虑扁平化法结合vector或智能指针。

2401_83389207的博客 400

Python控制Keysight DAQ973A/DAQ970A实现数据采集

本文介绍了如何通过编程实现Keysight DAQ973A数据采集系统的自动化温度测量。首先,通过GPIB线将PC与仪器连接,并使用热电耦测量线连接被测装置。接着,通过查阅Keysight官网提供的编程手册,获取了实现温度测量所需的SCPI指令。然后,使用pyvisa库编写代码,与仪器进行交互,发送SCPI指令并读取测量结果。代码中整合了配置和查询指令,并将测量结果转换为浮点数格式。最后,将整个流程封装为命令行工具,用户可以通过配置文件设置参数,并执行自动化测试,测试结果将保存为CSV文件。整个过程实现了温

xgh1951的博客 1893

【异常检测】【EfficientAD】论文简单梳理与代码实现

EfficientAD作为较近的一篇异常检测网络,主要还是从S-T网络入手,对齐进行了相关改进。修改特征提取器引入自动编码器hard loss以及惩罚项。

胡侃有料的博客 2863

c语言行指针 列指针,行指针列指针

#include using namespace std;int main(){int s1[3];int (*p1)[3] = s1; // error, s1为列指针,p1为数组指针,这里理解为行指针int (*p2)[3] = &s1; // ok, 列指针取地址即为行指针int *p3 = s1; // okint s2[3][4];int (*p4)[3][4] = s2; //...

weixin_29758911的博客 444

【智能座舱】- 智能座舱研究报告合集

智能座舱研究报告合集

零点壹客的博客 1307

C++程序设计基础学习笔记:(6)指针:所向披靡的“金箍棒” 魂

第6章 指针:所向披靡的“金箍棒” 魂 6.1 指针概述及基本应用 内存地址 计算机的内存被划分为一个个的存储单元,简称内存单元。 内存单元按一定的规则编号,这个编号就是存储单元的地址。 变量与内存地址 程序中定义的变量要占用一定的内存空间,不同的数据类型的变量占用的内存空间大小不一样。 访问内存中的数据 从内存单元中访问数据的方法有两种:直接访问和间接访问。 直接访问 通过变量名,直接对变量的存储单元进行存取访问。 定义变量后,该变量名也就成为了相应内存空间的名称,表现在程序语句中就是通

呆呆象呆呆的博客 1581

【VTKExamples】PolyData-1:: CellEdgeNeighbors & CellPointNeighbors 检索Cell边相邻的Cells & 检索Cell点相邻的Cells

本文主要分享VTKExample中两个样例CellEdgeNeighbors.cxx & CellPointNeighbors.cxx,了解VTK中如何对Cell进行邻域检索!输入模型 基于Edge检索结果 基于Point检索结果目录前言1. 基于Edge检索核心代码2.基于Point检索核心代码3.基于Edge检索样例代码4. 基于Point检索样例代码1.

qq_40041064的博客 675

jdk-8u144-linux-x64.tar.gz.

该资源为搭建Linux系统Java环境用,资源的后缀为tar.gz格式的压缩包

二维数组的动态内存申请,采用子函数的方式 为二级指针申请内存,和释放内存

原理:二级指针,行指针+列指针 照着葫芦画瓢就行。 方法一:用c语言malloc实现 #include<cstdio> #include<iostream> #include<cstring> #include<string> //二维数组的动态内存申请,采用子函数的方式 为二级指针申请内存,和释放内存 int** creatArray2D(int row, int col) { //int *p=(int*)malloc(sizeof(in.

zjjaibc的博客 2878

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

用行列指针遍历输出

//用列指针(指向一个元素的指针)和行指针两种方式对二维数组元素进行遍历输出。 #include using namespace std; void output_h(int (*p)[3],int n); void output_l(int *p,int n); int main() {  int a[2][3]={1,2,3,4,5,6};  output_h(a,2);

853

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

LinePhone3.2.7(android端最新版本) sip客户端

SIP客户端For android:LinePhone3.2.7(最新版本),官网地址:http://www.linphone.org/

三种方法进行二维数组遍历输出---下标法、行指针、列指针

/* 二维数组遍历输出(3种方法) (1)下标方法 (2)列指针方法 (3)行指针方法 */ #include using namespace std; void output_Subscript(int p[][4],int n); void output_Line(int p[][4],int n); void output_Column(int *p,int n);

smallgyy的专栏 5198

行指针与列指针的联系和区别

两个重要概念:行指针和列指针。行指针:指的是一整行,不指向具体元素。列指针:指的是一行中某个具体元素。可以将列指针理解为行指针的具体元素,行指针理解为列指针的地址。那么两个概念之间的具体转换是:*行指针----列指针&amp;列指针----行指针数组的 “[]” 其实就是取内容的意思int main() { int a[3][3] = { 1,2,3,4,5,6,7,8,9 }; int *p...

浅陌风型 5625

C++以二维数组作为函数的参数(绝对会将你给讲明白的)

文章目录数组名和指针的含义方法一,使用数组下标符号"[]"传递二维数组使用行指针访问二维数组通过行指针访问二维数组 数组名和指针的含义 根据上述程序的运行结果分析 数组名是数组首元素的地址 一维数组的元素是单个的元素,数组名就是第一个元素的地址 二维数组的元素是一维数组,数组名就是第一个元素的地址,第一个元素是一维数组,一维数组的地址就是一位数组中第一个元素的地址,所以二维数组的数组名在数值上和第一个一维数组的第一个元素的地址相同,但是实际意义不同 因为二维数组的第一个元素是一个一维数组,是

Blackoutdragon的博客 5234

矩阵转置(二维数组)(三种方式 行指针与列指针)

【问题描述】请写一函数,将一个m*n的整型矩阵转置。注意:请将转置后的数据存储到二维数组中以后,再对二维数组进行输出。【友情提示】注意第三个转置方法在计算行列个数时,使用原始行列总个数。【输入形式】矩阵长度和宽度及矩阵元素值。【输出形式】调用三个函数转置后的矩阵。

heliotrope_jin的博客 2432
上一篇: 《C程序设计语言》笔记 第5章 指针与数组
下一篇: 《C程序设计语言》笔记 第6章 结构
zzy979
博客等级 码龄9年 153粉丝 98原创
评论 15
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值
⌂ 换网址