数据类型 - 数组与指针 （转自万一老师）

最新推荐文章于 2024-07-19 15:37:00 发布
最新推荐文章于 2024-07-19 15:37:00 发布
阅读量576 收藏
点赞数
分类专栏： 技术文章 文章标签： n2 list button string forms float
1. 获取数组的地址无须 &, 因为数组名本身就是个地址 
#include <stdio.h>

int main()
{
    char c = 'A';
    char cs[] = "ABC";

    printf("%c, %s/n", c, cs);           /* 获取字符及字符数组的内容 */
    printf("%p, %p, %p/n", &c, cs, &cs); /* 获取字符及字符数组的地址, cs 与 &cs 没有区别*/

    getchar();
    return 0;
}

2. 数组元素的地址是连续的: 
#include <stdio.h>

int main()
{
    char cs[] = "ABC";

    printf("%p/n%p/n%p/n%p/n", cs, &cs[0], &cs[1], &cs[2]);

    getchar();
    return 0;
}

3. 数组名所代表的地址就是第一个元素的地址: 
#include <stdio.h>

int main()
{
    char str[] = "ABC";
    char *p1 = str;
    char *p2 = &str[0];

    printf("%p, %p/n", p1, p2);

    getchar();
    return 0;
}

4. 通过指针访问数组元素: 
#include <stdio.h>

int main()
{
    char str[] = "ABC";
    char *p = str;

    printf("%c/n", *p);
    printf("%c/n", *p+1);
    printf("%c/n", *p+2);

    printf("/n");
    
    printf("%c/n", *p);
    printf("%c/n", *++p);
    printf("%c/n", *++p);

    getchar();
    return 0;
}

5. 通过指针遍历数组: 
#include <stdio.h>

int main()
{
    char str[] = "123456789";
    char *p = str;

    int i;
    for (i = 0; i < sizeof str/sizeof str[0]; i++) {
        printf("%c/n", *p);
        p++;
    }

    getchar();
    return 0;
}

  
  
#include <stdio.h>

int main()
{
    char str[] = "123456789";
    char *p = str;

    while (*p != '/0') {
        printf("%c/n", *p);
        p++;
    }

    getchar();
    return 0;
}

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

int main()
{
    char str[] = "123456789";
    char *p = str;

    int i;
    for (i = 0; i < strlen(str); i++) {
        printf("%c/n", *(p+i));
    }

    getchar();
    return 0;
}

  
  
#include <stdio.h>

int main()
{
    int nums[] = {111,222,333,444};
    int *p = nums;

    int i;
    for (i = 0; i < sizeof nums / sizeof nums[0]; i++) {
        printf("%d/n", *p++);
    }

    getchar();
    return 0;
}

6. 注意: 指针+1 是根据元素大小移动一个位置 
#include <stdio.h>

int main()
{
    int nums[] = {111,222,333,444};
    int *p = nums;

    int i;
    printf("%d/n", *p);
    printf("%d/n", *(p+1));

    printf("%d/n", *p+1);  /* 不是这样; 这是代表取值后再 + 1 */
    
    getchar();
    return 0;
}

  
  
unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

{分割字符串的函数, 其实是个过程}
procedure Split(const str: string; const c: Char; var List: TStrings);
begin
  List.Clear;
  List.Delimiter := c;
  List.DelimitedText := str;
end;

{调用测试}
procedure TForm1.Button1Click(Sender: TObject);
var
  List: TStrings;
  s: string;
  c: Char;
begin
  s := 'aaa;bbb;ccc;ddd';
  c := ';';

  List := TStringList.Create;
  Split(s,c,List);
  ShowMessage(List[1]); {bbb}
  List.Free;
end;

end.
 

1. 通过 &变量 可以获取变量地址: 
#include <stdio.h>

int main()
{
    int num = 10;

    printf("变量值: %d/n", num);
    printf("变量址: %d/n", &num);

    getchar();
    return 0;
}

2. 表示变量地址的变量就是指针: 
#include <stdio.h>

int main()
{
    int num = 10;
    int *p = &num;

    printf("%d, %p/n", num, p);
    
    getchar();
    return 0;
}

3. *指针 就如同变量本身是一样的: 
#include <stdio.h>

int main()
{
    int num = 10;
    int *p = &num;

    printf("%d, %p, %d/n", num, p, *p);

    *p = 11;
    printf("%d, %p, %d/n", num, p, *p);

    (*p)++;
    printf("%d, %p, %d/n", num, p, *p);

    num = 99;
    printf("%d, %p, %d/n", num, p, *p);
    
    getchar();
    return 0;
}

4. 声明指针时要注意初始化, 没有初始化的指针是危险的: 
#include <stdio.h>

int main()
{
    int n1 = 11;
    int n2 = 22;
    int *p = NULL; /* 初始化为空 */

    p = &n1;
    printf("%d, %p, %d/n", n1, p, *p);

    p = &n2;
    printf("%d, %p, %d/n", n2, p, *p);

    getchar();
    return 0;
}

5. 指向常量的指针: 不能通过指针修改它指向的值, 但该值可以通过其变量修改 
#include <stdio.h>

int main()
{
    int n1 = 111;
    int n2 = 222;
    const int *p = &n1;  /* 注意 const 的使用 */

    printf("%d, %p, %d/n", n1, p, *p);

    n1 = 333;
    //*p = 333; /* 不可以这样, 因为现在的指针是常量 */
    printf("%d, %p, %d/n", n1, p, *p);

    p = &n2;    /* 可以改变指针的指向 */
    printf("%d, %p, %d/n", n2, p, *p);

    getchar();
    return 0;
}

6. 常量指针: 锁定指针的指向 
#include <stdio.h>

int main()
{
    int n1 = 111;
    int n2 = 222;
    int *const p = &n1; /* 注意 const 的使用 */

    printf("%d, %p, %d/n", n1, p, *p);

    n1 = 333;
    //*p = 333; /* 不可以这样, 因为现在的指针是常量 */
    printf("%d, %p, %d/n", n1, p, *p);

//    p = &n2;    /* 现在不可以改变指针的指向了 */
//    printf("%d, %p, %d/n", n2, p, *p);

    getchar();
    return 0;
}

7. 指针是有类型的: 
#include <stdio.h>

int main()
{
    long   n    = 100L;
    float  f    = 1.5f;
    double d    = 3.14159265;
    
    long   *p1   = &n;
    float  *p2   = &f;
    double *p3   = &d;

    printf("%ld/n", *p1);
    printf("%g/n",  *p2);
    printf("%.8f/n",*p3);

    getchar();
    return 0;
}

 

1. 数组的标志是 []: 
#include <stdio.h>

int main()
{
    int nums[3];

    nums[0] = 11;
    nums[1] = 22;
    nums[2] = 33;

    printf("%d, %d, %d", nums[0], nums[1], nums[2]);
    
    getchar();
    return 0;
}

2. 数组的大小和维数: 
#include <stdio.h>

int main()
{
    int nums[10];

    printf("数组大小是: %d/n", sizeof(nums));
    printf("数组维数是: %d/n", sizeof(nums)/sizeof(nums[0]));
    getchar();
    return 0;
}

3. 遍历数组: 
#include <stdio.h>

int main()
{
    int nums[10];

    int i;
    for (i = 0; i < sizeof(nums)/sizeof(nums[0]); i++) 
        nums[i] = i * i;
        
    for (i = 0; i < sizeof(nums)/sizeof(nums[0]); i++) 
        printf("%d/n", nums[i]);

    getchar();
    return 0;
}

4. 对一维数组, 可以不指定维数, 它能自动识别: 
#include <stdio.h>

int main()
{
    double ds[] = {1.1, 2.2, 3.3, 4.4};
    
    int count = sizeof ds / sizeof ds[0];
    int i;
    
    for (i = 0; i < count; i++) {
        printf("%.1f/n", ds[i]);
    }
    
    getchar();
    return 0;
}

4. 不指定维数的数组常常会用于字符串: 
#include <stdio.h>

int main()
{
    char str1[] = "Builder";

    /* 假如不怕麻烦可以这样初始化 */
    char str2[8] = {'B','u','i','l','d','e','r','/0'};
    
    unsigned i;
    for (i = 0; i < sizeof str1/sizeof str1[0]; i++) {
        printf("%c", str1[i]);    
    }

    printf("/n%s", str1);
    printf("/n%s", str2);
    
    getchar();
    return 0;
}

5. 二维数组: 
#include <stdio.h>

int main()
{
    int nums[3][4] = {
                       {11,12,13,14},
                       {21,22,23,24},
                       {31,32,33,34}
                     };

    printf("%d,%d,%d/n", nums[0][2], nums[1][2], nums[2][2]);

    getchar();
    return 0;
}

5. 可以并只能省略第一个维数: 
#include <stdio.h>

int main()
{
    int nums[][4] = {
                       {11,12,13,14},
                       {21,22,23,24},
                       {31,32,33,34}
                     };

    printf("%d,%d,%d/n", nums[0][2], nums[1][2], nums[2][2]);

    getchar();
    return 0;
}

6. 多维数组: 
#include <stdio.h>

int main()
{
    int nums[2][3][4] = {
                          {
                            {111,112,113,114},
                            {121,122,123,124},
                            {131,132,133,134}
                          },
                          {
                            {211,212,213,214},
                            {221,222,223,224},
                            {231,232,233,234}
                          }
                        };

    printf("%d,%d,%d/n", nums[0][0][0], nums[1][1][1], nums[1][2][2]);
    getchar();
    return 0;
}

7. 多维数组也是可以并只能省略第一个维数: 
#include <stdio.h>

int main()
{
    int nums[][3][4] = {
                          {
                            {111,112,113,114},
                            {121,122,123,124},
                            {131,132,133,134}
                          },
                          {
                            {211,212,213,214},
                            {221,222,223,224},
                            {231,232,233,234}
                          }
                        };

    printf("%d,%d,%d/n", nums[0][0][0], nums[1][1][1], nums[1][2][2]);
    getchar();
    return 0;
}

8. 没有初始化的局部数组变量, 包含的是一堆垃圾值: 
#include <stdio.h>

int ns1[10];     /* 这个会初始化为空 */

int main()
{
    int ns2[10]; /* 这个不会初始化 */

    int i;
        
    for (i = 0; i < sizeof(ns1)/sizeof(ns1[0]); i++) 
        printf("%d/n", ns1[i]);

    printf("------------/n");
    
    for (i = 0; i < sizeof(ns2)/sizeof(ns2[0]); i++) 
        printf("%d/n", ns2[i]);

    getchar();
    return 0;
}

9. 初始化数组为空其实很简单: 
#include <stdio.h>

int main()
{
    int ns1[10] = {NULL}; /* 或 {0} */
    int ns2[2][3][4] = {0};

    int i;
    for (i = 0; i < sizeof(ns1)/sizeof(ns1[0]); i++) 
        printf("%d/n", ns1[i]);

    printf("---------/n");
    printf("%d/n", ns2[1][2][3]);

    getchar();
    return 0;
}

1. printf 枚举可显示枚举的序号: 
#include <stdio.h>

int main()
{
    enum ABC{AAA,BBB,CCC};

    enum ABC e1,e2,e3;

    e1 = AAA;
    e2 = BBB;
    e3 = CCC;
    
    printf("%d, %d, %d/n", e1, e2, e3);
    getchar();
    return 0;
}

2. 定义枚举时可同时定义变量: 
#include <stdio.h>

int main()
{
    enum ABC{AAA,BBB,CCC} e1=BBB, e2=BBB+1, e3=e2-2;
    
    printf("%d, %d, %d/n", e1, e2, e3);
    getchar();
    return 0;
}

3. 同时定义变量时, 你甚至可以不要枚举名: 
#include <stdio.h>

int main()
{
    enum {AAA,BBB,CCC} e=BBB;
    
    printf("%d/n", e);

    e++;
    printf("%d/n", e);
    
    getchar();
    return 0;
}

4. 可随意指定序号: 
#include <stdio.h>

int main()
{
    enum ABC{AAA=2,BBB,CCC=9} e1, e2, e3;

    e1 = AAA;
    e2 = BBB;
    e3 = CCC;
    
    printf("%d, %d, %d/n", e1, e2, e3);
    getchar();
    return 0;
}

5. 序号重了都不要紧: 
#include <stdio.h>

int main()
{
    enum ABC{AAA=2,BBB=2,CCC} e1, e2, e3;

    e1 = AAA;
    e2 = BBB;
    e3 = CCC;
    
    printf("%d, %d, %d/n", e1, e2, e3);
    getchar();
    return 0;
}
gxsky
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
复杂的数据类型(数组，指针)
sxdahh的博客
03-10 481
复杂=简单+简单 介绍三种数据类型:数组，指针，数据结构。 数组 数组是许多程序设计语言的重要组成部分，尤其在c程序中经常用到它们。 数组的优点在于，一个数组可以把多个不同类型的值存储在同一个变量名下。 数组仍需要被声明为某一种特定的类型:int,float,char type name[x]; 注意:我们不会把不同数据类型的数据混杂保存在同一个数组中，(不同物种不可杂交)。 指针 c语言和c++...
【C语言的数组指针，指针数组及数组与指针的区别】
qq_64318258的博客
10-26 421
本文重点强调了如何区分数组指针和指针数组，还有数组和指针的区别。
几种不同类型数组与指针的关系
qq_44054750的博客
12-11 1441
1)整形数组与指针 int a[5]={1,2,3,4,5}; int *p=a;//其实指针p也相当于是数组名，p[i]=a[i];指向数组首地址，即a[0]地址； cout&amp;lt;&amp;lt;p;即输出数组a的首地址；(与cout&amp;lt;&amp;lt;&amp;amp;a[0]等价 ） cout&amp;lt;&amp;lt;*p;即输出a[0]; ！！！！cout&amp;lt;&amp;lt;&a
Delphi 数据类型列表
weixin_34209406的博客
12-04 311
分类 范围 字节 备注 简单类型 序数 整数 Integer -2147483648 .. 2147483647 4 有符号32位 Cardinal 0 .. 4294967295 4 无符号32位 ...
21、基本数据类型的包装类
总想试试，万一成了呢？？
11-22 155
1、Java设计的基本原则：一切皆对象，一切操作都以对象的形式进行描述。此时我们发现，有一个矛盾点，基本数据类型不是对象。对于这个矛盾点，我们可以进行处理： class MyInt { // 定义类 private int num; // 类封装基本数据类型 // 定义构造方法，将基本数据类型传递给对象 public MyInt(int num) { th...
【黑马程序员】从0到1入门学C++ -数据类型-Switch语句-数组-函数-指针-结构体
mhyasadj的博客
01-11 1022
虽然已经有很多人写了笔记，但我为了查漏补缺，还是重新学习了一遍。我这个笔记重点记录了C++中一些比较容易被忽略的知识点，适合有一定c语言或者c++基础的同学进行复习
指针与数组
热门推荐
m0_60292931的博客
04-06 1万+
较为的详细介绍了 指针与数组的关系
Java篇第二回——基本数据类型与数组
xingxingk88的博客
12-30 612
好久没写过了，今日无聊
c语言指针和数组的联系,C语言学习笔记--指针和数组的关系
weixin_39765290的博客
05-19 292
1.数组的本质(1)数组是一段连续的内存空间(2)数组的空间大小：sizeof(array_type)*array_size;(3)数组名可看做指向数组第一个元素的常量指针(4)数组声明时编译器自动分配一片连续的内存空间 ，而指针声明时只分配了用于容纳地址值的 4 字节空间2.指针的运算(1)指针是一种特殊的变量，与整数的运算规则为：p + n == (unsigned int)p + n * s...
C语言中数组与指针的探讨.pdf
12-25
数组可以被视为一组相同类型的元素集合，而指针则是一个变量，它存储的是内存地址，这个地址通常指向另一个变量。理解这两者的关系对于深入学习C语言至关重要。 首先，数组的本质其实是一个连续的内存空间，用来...
oc-数组倒叙
04-22
在Objective-C（简称OC）中，数组是一种常用的数据结构，用于存储多个有序的元素。当你需要将数组中的元素顺序反转，即实现数组的倒序，可以采用多种方法。本篇文章将详细讲解如何在OC中实现数组倒序的操作。 首先...
第9章-用户自定义数据类型-21
08-03
在编程中，自定义数据类型是提升代码可读性和复用性的重要手段。在C语言中，我们可以使用结构体(struct)、共用体(union)和枚举类型(enum)来创建自定义的数据类型。本章节重点讲解了如何声明和使用这些自定义类型。 ...
11-指针（三）-自己使用的C语言教程PPT-适合老师备课或者自学.pptx
11-25
本教程主要探讨了三个关于指针的关键知识点：指向结构体变量的指针、指向结构体数组的指针以及结构体数据作为函数参数。 11.1 指向结构体变量的指针变量： 指针可以指向基本类型如int、char等，同样也可以指向...
10-指针（二）-自己使用的C语言教程PPT-适合老师备课或者自学.pptx
11-24
指针数组的主要用于管理同种类型的指针，其中最常用在处理若干个字符串（如二维字符数组）的操作。 在下面的例子中，我们将学习如何使用指针数组来解决问题： ```c void sort(char *str[], int n) { char *temp; ...
ArrayList.subList的踩坑
weixin_57259781的博客
07-17 261
表示从下标为1的数据开始截取list中的除了下标为0的其他所有数据。表面上看好像没什么问题，若从数据库里面查出来的companyList 的长度为2，那么下标范围为0和1，使用该方法最终获取的companyList为空，和我们想要的预期值不合。若list中只有两个元素，跳过第一个元素获取剩下的元素，若使用ArrayList.subList（1,1）是不对的，用数学表达式表达就是[1,1)不会获取到第二个元素，截取后获取的数组为空。需求描述：跳过list中的第一个元素，获取list中的其他元素。
定制QCustomPlot 带有ListView的QCustomPlot 全网唯一份
DreamLife
07-17 1149
魔改QCustomPlot，支持QLIstView 和 QScrollArea滚动。支持数百条甚至上千条数据显示。只是拖拽改变数据顺序，支持自定义图例，曲线支持上下拖拽改变Y轴大小。
组合数学+费用背包+刷表，G2 - Playlist for Polycarp (hard version)
最新发布
EQUINOX1的博客
07-19 365
然后 (f(i, j, k, 0) + f(i, j, k, 1) f(i, j, k, 2)) * g(j, k, p) * h(i, T - p) * fac(i) * fac(j) * fac(k) 就是一组方案数。考虑转换一下，g(j, k, p) 为 j个 类型2，k 个类型3 总费用为t方案数，h(i, T - p)为i个类型1，总费用为t的方案数，乘法原理二者相乘可得。f(i, j, k, x) 为 选取 i 个类型1，j个 类型2，k 个类型3，并且以类型x结尾，且无相同相邻项的方案数。
LinkedList
qq_64633597的博客
07-16 665
源码图解0515toString重写next prev 产生问题。
王桂林老师详解C语言进阶：数据类型、进程空间与数组指针
此外，还涉及数组指针的概念，纠正了一维数组名的常见误解，并展示了其在实际编程中的应用。 4. 指针概念： - 讲解了内存编址与变量地址的关系，深入剖析指针在C语言中的作用。通过实例让读者理解指针如何指向内存...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值