C 语言数组

#import <Foundation/Foundation.h>

#define knum 5
#define kArr "shuguangnvshen"
int main(int argc, const char * argv[]) {

    //数组:数组是一组具有相同数据类型的成员组成的有序的集合
    //格式:类型修饰符 数组名=(赋值运算符) {数组元素};
    //访问数组元素:数组名加下标;
    /*
     int array[]={12,3,4,8};
                   0 1 2 3
     array[0];//12
     */
//
//    int arr[]={1,2,3,4};
//    //[] 中括号    里面是我们数组元素的个数
//
//
//    int arr1[8-4]={1,2,3,44};
//    //数组元素个数可以使用常量表达式来表示
//
//
//
//    //中括号里面放的只能是常量 这里放的是变量所以是错误的
//    int a =4;
//    int arr2[a]={1,3,4,5,}
//
////
//    int arr2[3]={0};
//    printf("%d\n",arr2[1]);
//
    //遍历数组元素
//    for (int i =0; i<3; i++) {
//        printf("%d",arr2[1]);
//    }
//

    //两种凡是打印数组元素
    //数组当中的元素下标是从0开始,最大下标我们数组的总元素个数减一
//    int arr3[5]={9,8,7,6,5};
//    printf("%d\n",arr3[0]);
//     printf("%d\n",arr3[1]);
//     printf("%d\n",arr3[2]);
//
//    for (int i=0; i<5; i++) {
//        printf("%d\n",arr3[i]);
//    }

    //如果我们中括号内什么都不写的话 那么我们系统会自动判断数组里边的个数
   // int array[]={1,2,3,4};

//    //如果我们花括号内部的元素不满足我们数组元素的总个数,那么我们系统会自动补零
//    int arr[4]={1,2,3};
//
//
//    //数组越界问题:
//    //数组元素个数和数组元素不匹配会发生数组越界的问题
//    //一定要避免数组越界的问题,因为发生数组越界问题的时候我们数组内部元素是不可以把控的.
//    int arr1[3]={1,2,3,4};
//    printf("%d\n",arr1[3]);
//    

//    //我们在定义数组的时候,如果我们没有给定我们数组的元素,那么为了避免一些问题的发生,我们应该去对我们的数组进行一个初始化(也就是赋值0的操作)
//    int arr2[4]={0};
//    //遍历数组的每个元素
//    for (int i=0; i<4; i++) {
//        printf("%d\n",arr2[i]);
//    }
//

    //字符数组
    //我们字符数组有一个特殊情况就是字符串数组  字符串数组默认是以"\0"结尾.多以当我们判断数组元素的个数时候不要去忽略"\0"
//    char ch[]={‘a‘,‘b‘,‘c‘,‘d‘,‘e‘,‘f‘};
//    printf("%c\n",ch[5]);
//    for (int i=0; i<7; i++) {
//        printf("%c\n",ch[i]);
//    }
//
//    //字符串数组
//    char ch1[]="iphone";
//    printf("%c\n",ch1[6]);
//    for (int i=0; i<7; i++) {
//        printf("%c ",ch1[i]);
//    }
////    //sizeof 打印出数组在内存中所占字节的
//
//    printf("数组ch=%lu\n",sizeof(ch1));
//    

//    int arr[4]={1,2,3,4};
//
//    printf("%lu\n",sizeof(arr));

//    float arr1[3]={3,12,24,55};
//    printf("%lu\n",sizeof(arr1));
//
//    

    //数组所占字节字节数大小=数组类型*元素个数

//
//    int array[5]={1,2,3,4,5};
//    //通过数组下表可以访问数组元素
//    printf("%d\n",array[4]);
//
//
//    //通过数组下标也可以去修改我们数组元素
//    array[4]=6;
//    printf("%d\n",array[4]);
//    for (int i=0; i<5; i++) {
//        printf("%d ",array[i]);
//    }
//    

   /* *定义?一个具有20个元素的整型数组,每个元素的 取值范围是30-70之间,求数组元素的和
    •复制一个数组,即两个数组容量一样,把其中一个数组中的元素复制到另外一个数组中
    •定义 2个数组,每个数组都有 10个元素 ,元素取值范围20-
    40之间,数组对应元素相加,放到另外一个数组中

    */

    //定义一个具有20 个元素的整型数组
//    int a[20];
//    //定于一个变量 接收他们相加的和
//    int sum=0;
//    //使用for循环接收随机出来的书序元素
//    for (int i=0; i<20; i++) {
//        a[i]=arc4random()%(70-30+1)+30;
//        sum=sum+a[i];
//        printf("%d ",a[i]);
//    }  printf("sum=%d\n",sum);
//
//
//
//    int b[20];
//    for (int i=0; i<20; i++) {
//        b[i]=a[i];
//        printf("b[%d]=%d\n",i,b[i]);
//    }

//
//    int a[10],b[10],c[10],i;
//    for (i=0; i<10; i++) {
//        a[i]=arc4random()%(70-30+1)+30;
//        b[i]=arc4random()%(70-30+1)+30;
//        c[i]=a[i]+b[i];
//        printf("a[%d]=%d",i,a[i]);
//        printf("b[%d]=%d",i,b[i]);
//        printf("c[%d]=%d\n",i,c[i]);
//    }
//
    //手抄6遍
    //敲20 次

    //for和我们数组联系起来 去计算
    //冒泡排序(要求我们是一个升序排列)
//    //首先定义一个无序的数组
//    int i, j, temp;
//    int a[5]={5,4,3,2,1};
//
//
//    //外层循环控制的是我们找出最终结果的一个趟数(元素个数-1)
//    for (j = 0; j < 4; j++)
//    {
//      //内层循环控制的是我们每次找出最大数字的次数
//        for (i = 0; i < 4 - j; i++)
//        {
//            //if()括号里面的>,<控制的是我们冒泡排序的一个升序或者是降序
//            if (a[i] >a[i + 1])
//            {
//                //定义第三方变量辅助交换,将a[i]的值赋值给我们temp此时我们a[]里边是一个空的
//                temp = a[i];
//                a[i] = a[i + 1];
//                //a[i+1]的值赋值给a[i],a[i+1]为空
//                a[i + 1] = temp;
//            }//第三方变量赋值给a[i+1];
//        }
//    }
//    打印输出
//    for (i = 0; i < 5; i++)
//    {
//        printf("%d,", a[i]);
//    }
//    printf("\n");
//

    //随机产?生10个[20,40]数 ,并对10个数从?小到?大排序
//
//    //首先定义一个int类型的数组,数组元素个数为10
//    int a[10];int temp=0;int i=0;
//    //使用随机数对数组进行赋值
//    for (int i=0; i<10; i++) {
//        a[i]=arc4random()%(40-20+1)+20;
//    }  printf("a[%d]=%d",i,a[i]);
//    //冒泡排序
//    for (int i=0; i<9; i++){
//        for (int j=0; j<9-i;j++){
//            if (a[j]>a[j+1]) {
//                temp = a[j];
//                a[j] = a[j + 1];
//                a[j + 1] = temp;
//            }
//        }
//
//    }
//        for (int j= 0;j < 10;j++)
//                {
//                    printf("%d,",a[j]);
//                }
//                printf("\n");

  /*  //stelen()计算字符串的长度
    字符串的内部表示使用一个空字符"\0"作为字符串的结尾.
    因此存储字符串的物理存储单元数比括在双引号中的字符串数多一个,这种表示方法也说明,c语言对字符串的长度是没有限制的,但是程序必须扫描完整个字符串后才能确定字符串的长度,标准库函数strlen()可以返回字符串参数的长度,但是长度不包括末尾的"\0"

    */
//    char ch[]="iphone";
//    //int  result=strlen(ch);
//    printf("%lu\n",strlen(ch));
//    //strlen()内部实现
//    int i=0;//用来计数
//    while (ch[i]!=‘\0‘) {
//        i++;
//    }

//
//    //字符数组
//    char ch1[]={‘i‘,‘p‘,‘h‘,‘o‘,‘n‘,‘e‘};
//     //int  result1=strlen(ch1);
//    printf("%lu\n",strlen(ch1));

    /*
     strcpy():字符串拷贝
     库函数strcpy(s,t)把指针t指向的字符串复制到指针s指向的位置,如果使用语句s=t实现该功能,其实他的是指只是拷贝了指针,而并没有赋值字符,为了进行字符的赋值,这里使用了循环语句,strcpy函数实质是拷贝指针没有赋值字符

     */
//    //这里将str复制到str1当中,我们要确定str1的元素个数一定要大于str的元素个数否则会发生数组越界的问题,
//    char str[]="iphone";
//    char str1[]=" ";
//    strcpy(str1, str);
//    printf("%s\n",str1);
//    //内部实现:
//    int i=0;
//    while ((str1[i]=str[i]!=‘\0‘)) {
//        i++;
//    }

    /*

     字符串拼接:strcat()
     现在有两个字符串s,t
     它是将字符串t连接到字符串s的尾部,函数strcat 嘉定字符串s中有足够的空间保存这两个字符串的连接结果.

     */
//
//    char t[]="s";
//    char s[]="io";
//    printf("%s ",strcat(s, t));//将第二个参数拼接到第一个参数的后边
    //注意s数组里面的元素个数一定要大于t数组元素个数(如果小于的话也是会发生数组越界的问题)
//    char a[]="iphone";
//    char b[]="6s";
//    printf("%s",strcat(a,b));

    /*
     字符串比较 stramp()
     字符串比较函数stramp(s,t)该函数比较字符串s,t,并且根据s按照字典顺序小于,等于或者大于t的结果分别返回负整数,0或者正整数
     该返回值是s,t由前向后注意字符比较式遇到第一个不相等的字符的差值

     如果比较的结果为零那么表示的两个字符串相等,如果返回的值是正整数的话,代表我们前边的字符串大 负整数则相反
     */
//    char a[9]="abo";
//    char b[10]="abc";
//    printf("%d",strcmp(a, b));
//
    //一个汉字占三个字节.
//    char ab[10]="蓝欧";
//    printf("%lu",strlen(ab));
//    

    //查找字符串中的空格数
    // I love ios, i want an iphone6s
//    //while循环
//    char b[]="I love ios, i want an iphone6s";
//    int i=0;//定义一个让循环开始的变量
//    int count=0;//定义变量记录空格数
//    //使用while循环
//    while (b[i]!=‘\0‘) {
//        if (b[i]==‘ ‘) {
//            count ++;
//        }
//        i++;
//
//    }
//    printf("%d",count);

    //使用for循环
//    char b[]="I love ios, i want an iphone6s";
//    int a=0;//a用来记录空格的个数
//    //使用strlen函数它是就计算我们字符串的个数
//    //并且该函数会自动忽略\0.我们不需要在考虑\0的情况
//    for (int i =0; i<strlen(b); i++) {
//        if (b[i]==‘ ‘) {
//            a++;
//        }
//    }printf("%d",a);
//    

//   /*
//     将字符串倒转
//     例如:“afjnpue”转变成字符串“eupnjfa”(注:是改变字符串本?身,不是反向输出
//
//     */
//    char str[]="afjnpue";
//
//
//    char temp;
//    int i,j;
//    j = strlen(str)-1;
//    for (i=0; i<j; i++) {
//        //首先第一个元素和最后一个元素进行交换,数组最大下标是strlen(str-1);而我们第一个元素下标为0.最后一个元素下标为strlen(str)-1-0;\倒数第二个元素下标为strlen(str)-1-1..........
//        temp=str[i];
//        str[i]=str[j];
//        str[j]=temp;
//        j--;
//    }
//    printf("%s",str);
////
//    

/*宏定义:
    //#define kArrlen 10//kArrlen: 是 宏名oc当中推荐使用的是驼峰命名法,首字母为k其他单词首字母字符大写

 #define ARR_LBN 10//是我们c语言但中宏定义的命名;所有字母大写,单词使用下划线分隔

// */
//    int arr[knum]={1,2,3,4,5};
//    int arr1[knum]={1,2,5};
//    int arr2[knum]={1};

//    char array[]=kArr;
//    char arrar1[]=kArr;
//    printf("%s\n",array1);

    /*
    带参数的宏
     #define MIN(A,B)A>B?A:B
     #define SOR(Num) Num*Num
     SQR(2+1)/SQR(2+1)编译过后变成:

     2+1*2+1/2+1*2+1=7;

    */

//    int a[5]={5,4,3,2,1};
//    int i,j,temp;
//    for (i=0; i<4; i++) {
//        for (j=0; j<4-i; j++) {
//            if (a[j]>a[j+1]) {
//                temp=a[j];
//                a[j]=a[j+1];
//                a[j+1]=temp;
//            }
//        }
//    }for (i=0; i<5; i++) {
//        printf("a[%d]=%d",i,a[i]);
//    }printf("\n");

    return 0;
}
时间: 2024-12-30 19:02:31

C 语言数组的相关文章

1.2 C语言---数组

1.2     C语言---数组 1.2.1    为什么引入数组? 数组就是数组成的一个组,数就是一个特定数据类型的变量,组就是说好多数放在了一起. 1.2.2    怎么定义数组? int a[4];     //定义了一个数组a,里面有4个int元素. 总结:数组中的所有元素必须是同一种数据类型,不可能在一个数组中存储两种数据类型的数. 1.2.3    怎么使用数组? 数组定义的时候作为整体进行定义.但是使用的时候不能作为整体来使用,使用时必须拆开使用数组中的 各个元素. 例如:int

Go语言数组的使用

Go 语言数组 Go 语言提供了数组类型的数据结构. 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整形.字符串或者自定义类型. 相对于去声明number0, number1, ..., and number99的变量,使用数组形式numbers[0], numbers[1] ..., numbers[99]更加方便且易于扩展. 数组元素可以通过索引(位置)来读取(或者修改),索引从0开始,第一个元素索引为 0,第二个索引为 1,以此类推. 声明数组

Go语言数组,切片

数组声明 Go 语言数组声明需要指定元素类型及元素个数,语法格式如下: var variable_name [SIZE] variable_type 以上为一维数组的定义方式.数组长度必须是整数且大于 0.例如以下定义了数组 balance 长度为 10 类型为 float32: var balance [10] float32 初始化数组 以下演示了数组初始化: var balance = [5]float32{1000.0, 2.0, 3.4, 7.0, 50.0} 初始化数组中 {} 中的

C语言数组:C语言数组定义、二维数组、动态数组、字符串数组

1.C语言数组的概念 在<更加优美的C语言输出>一节中我们举了一个例子,是输出一个 4×4 的整数矩阵,代码如下: #include <stdio.h> #include <stdlib.h> int main() { int a1=20, a2=345, a3=700, a4=22; int b1=56720, b2=9999, b3=20098, b4=2; int c1=233, c2=205, c3=1, c4=6666; int d1=34, d2=0, d3

车牌识别--模板库C语言数组的制作

在车牌识别中,字符模板匹配的模板库是很大的. 包括 10个阿拉伯数字以及26个英文字母还有几十个汉字,每个库都是一张小图片,加载起来也比较繁琐. 后面还有可能为提高识别增加额外的模板库. 之前的处理中,是把这些库的图片文件放到一个文件夹中,程序启动后,再一个一个读取,这样文件的数量就比较多. 原图片模板如下: 程序稳定后,我们就不要这些字符模板库了,可以用数组的形式代替,就是把这些文件数据保存一个c语言数组里面,直接编译到程序中,运行程序的时候直接使用,不用一个一个加载,再去匹配. 目前使用的m

C语言数组元素下标为何从0开始

很多同学可能在学习数组时会有这个疑问,下标为什么不从1开始呢?从1开始不是更符合大家的日常习惯吗?生活中我们通常说第1个,而不是第0个.的确,有些计算机语言如早期的Pascal语言,数组元素的下标是从1开始的.难道是C语言故意要与众不同?要弄清楚这个问题,得先看一下计算机底层是怎样处理数组元素的.我们先编写了一个小程序,然后在visual studio中对其进行了反汇编.源程序和反汇编后的部分代码如下: 源程序: int arr[5];  //一个全局数组 int main() { int i;

R类型4R 语言数组

p.p1 { margin: 0.0px 0.0px 0.0px 0.0px; font: 17.0px ".PingFang SC"; color: #454545 } p.p2 { margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px ".PingFang SC"; color: #454545 } p.p3 { margin: 0.0px 0.0px 0.0px 0.0px; font: 12.0px "Helv

GO语言学习(十四)Go 语言数组

Go 语言数组 Go 语言提供了数组类型的数据结构. 数组是具有相同唯一类型的一组已编号且长度固定的数据项序列,这种类型可以是任意的原始类型例如整形.字符串或者自定义类型. 相对于去声明number0, number1, ..., and number99的变量,使用数组形式numbers[0], numbers[1] ..., numbers[99]更加方便且易于扩展. 数组元素可以通过索引(位置)来读取(或者修改),索引从0开始,第一个元素索引为 0,第二个索引为 1,以此类推. 声明数组

c语言 数组类型

数组类型重命名数组类型由元素类型和数组大小共同决定数组指针是一个指针,只想对应类型的数组指针数组是一个数组,其中每个元素都是指针数组指针遵循指针运算法则指针数组拥有c语言数组的各种特性 c通过typedef 为数组类型重命名格式为 typedef type(name)[size] 数组类型:typedef int(aint5)[5] typedef float(afloat10)[10] 数组定义:aint5 iarray; //定义了一个数组afloat10 farray; //定义了一个数组

C语言数组寻址

C语言数组 数组的定义 数组是用来存放数据类型相同且逻辑意义相同的数据 数组的大小 数组的大小不能是变量,必须是常量或者常量表达式,常量表达式由编译器编译时自动求值. 也可以不指定数组大小,但必须对数组进行初始化,编译器在编译时会根据初始化列表中元 素的个数计算数组大小,例如: int nAry[]={1,3,4}; 数组的初始化 在定义数组时可以使用初始化列表进行初始化,例如: int nAry[3]={0,3,3}; 但是只能在定义时使用这种方式赋值,在其他地方只能进行单个元素赋值. 如果数