2015-12-28 15:23:49 shiningchen322 阅读数 2158

一维数组转二维数组

   int bb = (int)self.OneRMBArray.count;

            

            NSLog(@"bb-->%d",bb);

            NSLog(@"self.OneRMBArray-->%@",self.OneRMBArray);

            

            NSMutableArray *data= [NSMutableArray new];//二维数组

            NSMutableArray *newa = [NSMutableArray new];//一维数组

           

            

            for (int i =0; i <bb; i++) {

                if (!(i%2)) {

                    newa = [NSMutableArray new];

                    [newa addObject:self.OneRMBArray[i]];

                   

                }

                else

                {

                    [newa addObject:self.OneRMBArray[i]];

                    [data addObject:newa];

                    NSLog(@"data222-->%@,,",data);

            

                }

            }

            NSLog(@"data222-->%@,,",data);

            

            newa=data;

            

            NSLog(@"data.count-->%lu,,",(unsigned long)data.count);

2015-08-29 08:57:48 baidu_30907803 阅读数 634

一:一维数组

数组数组也是一种构造类型(跟枚举类似,是一个构造类型),相同数据类型组成的新数据类型,数组的每一个成员成为一个数组元素;

数组是一串“连续”的内存空间,并且类型相同;

格式:类型修饰符 数组名[常量表达式(可直接是常量,也可是是定义的常量字符)]={值1,值2,·····值n};这里的常量表达式表示有多少个元素,比元素的下标要多1,因为下标是从0开始的。如下例子:

int a[5]={0};这里表示整型的数组名为a的数组有5个元素(a[0],a[1],a[2],a[3],a[4]),并且全赋初值为0;

但是int a[5]={1};则表示只有首个元素a[0]=1,其他默认为0,跟上面的有所不同;

int a[]={1,2,1,3,5,6};这个数组的长度[ ]的值则由后面的{ }的个数决定;

常用的有:(1)int a[2]={1,3}或(2)int a[5]={0}

其他类型的:跟整型数组一样的定义方法

浮点型的数组:float b[]={2.3,2.5};

字符型的数组:char str[]="iphone5";注意的是这里str[ ]数组的长度比实际的字符串的字符个数要多一位,因为字符串的结束符是‘\0’;但是char str[]={'i','p','h','o','n','e','5'};这种的数组长度就实实在在的等于字符的个数。

注意:系统不会检验数组元素的下标是否越界的问题,因此需要自己注意

数组是一个整体,不能直接参与运算,只能对单个元素进行处理,这里就必须用到循环实现,如下练习:

课上练习:

练习1:定义一个具有20个元素的数组,每个元素的取值范围是30~70,并且数组的和

int a[20]={0};

int sum=0;

for(int i=0;i<20;i++){

 a[i]=arc4random()%(70-30+1)+30;

printf("a[%d]=%d",i,a[i]);//赋值一个,就打印一个

sum+=a[i];

}

printf("%d",sum);

//    //整体打印方法
//    for(int i=0;i<20;i++){
//        printf("a[%d]=%d",i,a[i]);
//    }
//    printf("sum=%d",sum);

练习2:

复制一个数组,即两个数组容量一样的,把其中一个数组的元素复制到另一个数组中

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

int b[5]={0};

for(int i=0;i<5;i++){

b[i]=a[i];

}

 for(int i=0;i<5;i++){
       printf("b[%d]=%d",i,b[i]);
   }

练习3

生成2个数组,每个数组都有10个元素,元素取值范围是20~40,对应元素相加,放到另一个数组中(一共三个元素)

int a[10]={0};

int b[10]={0};

int c[10]={0};

for(int i=0;i<10;i++){

a[i]=arc4random()%(40-20+1)+20;

b[i]=arc4random()%(40-20+1)+20;

c[i]=a[i]+b[i];

}

//    for(i=0;i<10;i++){
//        printf("a[%d]=%d,b[%d]= %d ,c[%d]=%d\n",i,a[i],i,b[i],i,c[i]);
//    }

二:数组排序

主要学习了冒泡排序(由小到大,或者由大到小排序),主要使用两个for循环,外层循环控制比较的趟数,比比较的个数要少一(count-1),内层循环则控制比较的轮数,比外层比较的趟数少i,(count-1-i);如下练习

随机产生10个20~40之间的数,并且对10个数有小到大排序

    int const n=20;
    int i;
    int a[n]={0};
    printf("\n原来的顺序:");
    for(i=0;i<n;i++){
        a[i]=arc4random()%(40-20+1)+20;
        printf("%d ",a[i]);
    }
    int j,k;
    for(i=0;i<n-1;i++){//10个数则需要进行n-1轮比较(趟数比较),也就是需要进行10-1轮单个数单个数的比较,如三个数(1,2,3)需要进行2趟单个数字的比较
        for(j=0;j<n-1-i;j++){//每轮比较里面需要进行n-i次两两比较,如三个数(1,2,3)需要进行2次单个数字的比较,比如1进行两两两比较的次数为n-i=3-1=2,也就是跟2两两比较后,还要跟3两两比较。2进行两两比较时,则只需要n-i=3-2=1次,也就是只跟3两两比较就行了。
            if(a[j]>a[j+1]){//数组的两两比较,要求由小到大排序
                k=a[j+1];//顺序大的(j+1)值小,则先用k把它保存起来
                a[j+1]=a[j];//顺序大的(j+1)空间装上值小的数组a[j]
                a[j]=k;//顺序小的a[j]装上值小的值
            }
        }
    }
    //注意,i=0,j=0,而不是从1开始,因为a[j],从a[0]开始,也就是j=0开始,j<n-1-i//
    printf("\n新的顺序,由小到大排序:");
    for(i=0;i<n;i++){
        printf("%d ",a[i]);
    }
    printf("\n");

三:字符数组

//定义有两种形式:
    char c1[]={'i','p','h','o','n','e'};
    char c2[20]="iphone";
    //后面这个是由‘\0’结束标识符的,所以比上面的那种多一位‘\0’

//while循环——》计算字符数组的字符个数

用while循环计算字符个数,但这种算法并不能应用于c2[20]="iphone"的字符个数统计,因为它有个结束符'\0',\但可以count=1;开始算起则可以计算。

int i=0,count=0;
    while (c1[i]!='\0') {
        printf("%c ",c1[i]);
        count++;
        i++;
    }

printf("\ncount=%d\n",count);

//strlen()---->计算字符数组的字符个数,跟上面的方法实现的结果一样,但无法计算"iphone"的字符个数,'\0'

printf("%lu\n",strlen(c2));//等效于上面的while循环的方法,字符串长度统计是不算'\0'的。

//求字节数--->用sizeof()运算方法:

    printf("%lu\n",sizeof(c1));//sizeof(c1)是一个运算符//结果为6
    printf("%lu\n",sizeof(c2));//结果为20

如果是int型的数组,则计算字节数,长度是则需要sizeof(a)/sizeof(int),也就是需要除以4,因为int占4个字节,而字符型char则只占一个字节

//字符串赋值给字符串数组:strcpy(装赋值的数组名,被赋值的数组名)

如:char c3[20]={0};

strcpy(c3, "iPhone");//后者赋值给前者
    printf("c3=%s\n",c3);

//字符串比较strcmp(比较的字符串1,比较的字符串2),比较后有一个结果,并用int 型的变量来接收

 int result=strcmp(c2, c3);
    printf("result=%d\n",result);

 //字符串拼接  strcat(c3, "asf");//后者拼接到前者
    strcat(c3, "asf");//后者拼接到前者//赋给c1不行,因为c1[]没有定义多少个元素是不行的,系统会报错。因此要赋值给一个有一定数组长度的元素,并且装得下的数组名
    printf("%s\n",c3);


练习3:

    //练习3:查找字符串中的空格数:
    //例如:
    //“I love iOS, i want an iPhone5s”6个空格
    char a[50]="I love iOS, i want an iPhone5s";
//    putchar(a[50]);
    int count=0;
    int i=0;
    while(a[i]!='\0'){//‘0’表示是结束符号
            if(a[i] == ' '){
                count++;
            }
         i++;
        }
    printf("%d\n",count);
//方法2:
for (i=0; a[i]!='\0'; i++) {
//        if (a[i]==' ') {
//        count++;
//      }
//    }
//    printf("\ncount=%d\n",count);


 //课本例题3:字符数组与一般的数组一样,也可以一次性的输入
    char str[10]={0};
    printf("请输入一个字符串:");
    scanf("%s",&str[0]);
    for(int i=0;i<10;i++){
        printf("%c",str[i]);
    }
    printf("\n");
    printf("\n%s\n",str);


    //练习4:
    //将字符串倒转:方法1(只用一个数组)
    char s1[50]="afjnpue";
//    printf("please input a string:");
//    gets(s1);//会提示出错,尽量不用咯
    printf("原来的是:%s\n",s1);
    long count=strlen(s1);
//    printf("%lu\n",count);
    char temp;
    for (int j=0; j<count/2; j++) {//对半方法
        temp=s1[j];
        s1[j]=s1[count-1-j];
        s1[count-1-j]=temp;
    }
//    puts(s1);//尽量不用
    printf("逆序后是:%s\n",s1);
    
    课上代码:方法2(更好)用两个数组
    char s1[]="sdfsdjfsdsfsa";
    printf("%s\n",s1);
    char s2[100]={0};
    for (int i=0; i<strlen(s1); i++) {
        s2[i]=s1[strlen(s1)-1-i];
    }
    printf("%s\n",s2);

    如下例子5:找出若干字符串的最大者,函数的定义在头文件下面
    void max_string(char str[][20],int i);//函数的声明。本题通过二维数组,第一表示行,第二表示列有20列
    char str[4][20]={"Basic","C","Java","JSP"};
    for(int i=0;i<4;i++){
        printf("%s ",str[i]);
    }
    printf("\n");
    max_string(str, 4);
    函数定义,并且放于头文件地方
    void max_string(char str[][20],int n)
    {
        char max_str[20];//用于存放最大的字符串
        strcpy(max_str, str[0]);//先假定二维数组中第0行的字符串最大
        for(int i=0;i<n;i++){
            if (strcmp(str[i],max_str)>0) {//如果当前的str[i]比较大
                strcpy(max_str,str[i]);//把当前比较大的字符串复制存入max_str中
                printf("the largest string is:%s\n",max_str);
            }
        }
    }


















2015-10-22 23:07:12 apple_darling 阅读数 534

//

//  main.m

//  CLesson04

//

//  Created by 亮亮 on 15/10/10.

//  Copyright (c) 2015 Darling.com. All rights reserved.

//  一维数组、数组排序、字符数组


#import <Foundation/Foundation.h>


int main(int argc,const char * argv[]) {   

#pragma mark 一维数组

   /*

     1、数组属于构造类型

     2、数组是由相同数据类型 成员 组成的一组数据

     3、数组名:存储不同数据类型的数组有各自对应的名称(名字可以随意起),但是要见名之意。

     4、数组由多个成员组合而成,每个成员被称为数组元素

     */

    

    ////     定义一个数组

    //    long a = 12;// 类型声明 变量名 赋初值

   //

    //    // int :声明数组的类型,数组类型一旦确定,那么数组的元素类型也确定下来

    //    // array : 数组名,给数组取的名字

    //    // [5] :确定数组的长度,数字是几,就放几个元素(元素的类型必须和数组的类型一致)

    //    // {} :表示给数组赋值,数组元素之间要使用逗号分隔

    //    int array[5] = {12, 23, 34, 45, 56};

    

    

    

    //    // 数组的内存占用

    //    printf("整形变量占用的字节数是:%lu\n",sizeof(a)); //无符号长整形使用%lu输出

    //    // 使用sizeof()函数求出数组占用的字节数

    //    printf("整形数组变量占用的字节数是:%d\n",sizeof(array)); // 5*4

    

    

    

    //    //我们在定义一个数组时,可以省略数组元素的个数,由编译器自动推断。注意1“[]”不能省

    //    int array1[] = {12, 23, 34, 45, 56};

    //    //我们在定义一个数组时,可以不给每个元素都赋值,没有赋值的元素,默认为0.

    //    int array2[5] = {12, 23, 34};

    //    //定义一个数组,给定了数组长度,首元素为0,其他元素不赋值,默认也是0.这样五个元素均为0

    //    int array3[5] = {0};// 注意:数组初始化时0尽量不要省去

    

    

    

    

    

    

    //    // 定义一个整形数组,有5个元素,分别是12213223.

    //    int array4[5] = {12, 21, 32, 23};

   //

    //    //数组元素的访问方式:数组名+下标

    //    //访问arrary中的32这个元素,数组名:array,下标,从0开始计数,32在第3个位置上,所以32的下标就是2.

    //    // []:在定义数组时,方括号中的数字表示声明数组的元素个数;而在访问数组元素时,方括号表示要访问的元素的下标。

    //    int temp = array4[2];

    //    printf("temp = %d, array4[2] = %d", temp, array4[2]);

    

    

    

    

    

    //    数组下标越界:数组下标超过了数组长度,访问了不属于数组的内存空间。

    //    注意2C语言中,没有数组下标越界保护机制,所以在写代码时,要注意避免下标越界。

    //    int temp = array4[5];

    //    printf("temp = %d, array4[5] = %d", temp, array4[5]);//数组下标越界(C中没有越界保护,OC中有越界保护)

    

    

    

    

    //    // 修改array数组的第2个元素,改为99

    //    array4[1] = 99;

    //    printf("array4[1] = %d", array4[1]);

   //

    //    // 定义一个新数组,array5,将array4的元素,原样赋给array5

    //    int array5[5] = {0};

    //    // array5 = array 4;这是错的。数组中,不能整体访问数组元素,而要逐一的遍历数组元素!

    ////    array5[0] = array4[0];

    ////    array5[1] = array4[1];

    ////    array5[2] = array4[2];

    ////    array5[3] = array4[3];

    ////    array5[4] = array4[4];

   //

    //    for (int i = 0; i < 5; i++) {

    //        array5[i] = array4[i];// 说明数组下标可以是常量,也可以是变量

   //

    //    }

    //    // 遍历数组时,一般使用for循环

    //    for (int i = 0; i < 5; i++) {

    //        printf("arrary5[%d] = %d\n", i, array5[i]);

    //    }

    

    

    

    

    

    

    

    // 1、定义一个具有20个元素的整型数组,每个元素的取值范围是【3070,求数组元素的和。

    //    // 直观写法,便于理解

    //    // 1、定义一个整形数组,长度20,初始化

    //    int array[20] = {0};

   //

    //    // 2、开启一个for循环,使用循环给数组元素赋值

    //    for(int i = 0; i < 20; i++){

    //        //2.1生成满足范围的20个随机数

    //        int temp = arc4random() % (70 - 40 + 1) + 30;

    //        //2.2 将生成的随机数赋给对应的元素

    //        array[i] = temp;

    //        printf("array[%d] = %d\n", i, array[i]);

    //    }

   //

    //    // 3、求数组元素的和

    //    // 3.1 定义一个保存和的变量

    //    int sum = 0;

    //    // 3.2使用for循环换便利数组元素,同时将元素累加起来

    //    for(int i = 0; i < 20; i++) {

    //        // 3.3累加

    //        sum = sum + array[i];

    //    }

   //

    //    printf("\n20个数组元素的和sum = %d",sum);

    

    

    // 精简方法

    //    // 1、定义一个整形数组,长度20,初始化

    //    int array[20] = {0};

   //

    ////    //经典面试题:(数组元素个数的计算)

    ////    printf("sizeof(arr) / sizeof(int)= %ld\n", sizeof(arr) / sizeof(int));

   //

    //    // 2、求和变量

    //    int sum = 0;

    //    printf("20个随机数为:\n");

    //    // 3、开启一个for循环,使用循环给数组元素赋值

    //    for(int i = 0; i < 20; i++){

    //        //3.1生成满足范围的20个随机数

    //        int temp = arc4random() % (70 - 40 + 1) + 30;

    //        //3.2 将生成的随机数赋给对应的元素

    //        array[i] = temp;

    //        sum = sum + array[i];

    //        printf("array[%d] = %d\n", i, array[i]);

    //    }

    //    printf("\n20个数组元素的和sum = %d",sum);

    

    

    // 2、复制一个数组,即两个数组容量一样,把其中一个数组中的元素复制到另外一个数组中。

    //    int arr1[5] = {12, 23, 34, 45, 56};

    //    int arr2[5] = {0};

   //

    //    for (int i = 0; i < 5; i++) {

    //        arr2[i] = arr1[i];

    //        printf("%d\t", arr2[i]);

   //

    //    }

    

    // 3、生成2个数组,每个数组都有10个元素,元素取值范围20-40之间,数组对应元素相加,放到另外一个数组中。

    //    // 1.定义三个数组,长度为10

    //    int array1[10] = {0};

    //    int array2[10] = {0};

    //    int array3[10] = {0};

    //    // 2.使用一个for循环,给第一,第二个数组分别赋值;再将前两个数组对应的元素,交给第三个数组

    //    for(int i = 0; i < 10; i++){

    //        // 2.1给第一个、第二个数组赋值

    //        array1[i] = arc4random() % (20 + 1) + 20;

    //        array2[i] = arc4random() % (20 + 1) + 20;

   //

    //        // 2.2将前两个数组对应的元素相加,赋给第三个数组对应的元素

    //        array3[i] = array1[i] + array2[i];

    //        printf("array1[%d] = %d, array2[%d] = %d, array3[%d] = %d\n", i, array1[i],i, array2[i],i, array3[i]);

   //

    //    }

    

    

#pragma mark 冒泡排序

   /*

     23 45 43 56 13五个元素

     第一趟:

     第一次:23 45 43 56 13

     第二次:23 43 45 56 13

     第三次:23 43 45 56 13

     第四次:23 43 45 13 56

     

     第二趟:

     第一次:23 43 45 13 56

     第二次:23 43 45 13 56

     第三次:23 43 13 45 56

     

     第三趟:

     第一次:

     第二次:

     

     第四趟:

     第一次:13 23 43 45 56

     */

    

    //    冒泡排序规律:公式1 趟数=元素个数-1;公式2每趟比较的次数=元素个数-当前的趟数

    //    两层for循环,外层循环比较趟数、内层控制比较次数

    

    // 趟数

   int array[5] = {23,45, 43, 56, 13};

    

    

    //外层循环,控制排序趟数,趟数 = 数组元素个数 - 1

   for (int i =0; i < 5 - 1; i++) {

        //内层循环,控制比较次数,每趟比较的次数=元素个数-当前的趟数(i + 1)

       for (int j =0; j < 5 -(i +1); j++) {

           // 判断,并且交换

            if (array[j] > array[j+1]) {  // 因为每趟比较,都要从下标为零开始,j在每次从外层循环进入内层时,下标都要加一,j在每次内层循环时,也会加一,所以,在这里使用j做下标是没有问题的。

               // 满足交换条件,开始交换位置

               // 定义一个临时变量

               int temp = array[j];

                array[j] = array[j+1];

                array[j+1] = temp;

            }

        }

    }

    

    printf("冒泡排序后:");

    //  使用for循环遍历打印数组

   for (int i =0; i < 5; i++) {

       printf("%d\t", array[i]);

    }

    

    

    /*练习:随机产生10[20,40],并对10个数从小到大排序。*/

    //    int arr[10] = {0};

   //

   //

    //    printf("10个随机数是:");

    //    for (int i = 0; i < 10; i++) {

    //        int num = arc4random() % (40 - 20 + 1) + 20;

    //        arr[i] = num;

    //        printf("%d ", arr[i]);

    //    }

   //

    //    int temp;

    //    for (int i = 0; i < 10; i++) {

   //

    //        for (int j = 0; j < 10 - 1 - i; j++) {

   //

    //            if (arr[j] > arr[j+1]) {

    //                temp = arr[j];

    //                arr[j] = arr[j+1];

    //                arr[j+1] = temp;

   //

    //            }

    //        }

    //    }

   //

    //    printf("\n排序后的10个数为:\n");

    //    for (int i = 0; i < 10; i++) {

    //        printf("%d\t",arr[i]);

    //    }

    

#pragma mark 字符数组

    //保存字符的数组,就是字符数组

    //    //定义一个字符数组第一种方式:声明类型、数组名、数组长度、赋初值

    //    char char_Array[5] = {'h', 'e', 'l', 'l', 'o'};

    //    printf("%lu\n", sizeof(char_Array));  //每个字符占一个字节,数组长度是5,所以数组占用5*1个字节的内存。

    //    char char_Array1[] = {'w', 'o', 'r', 'l', 'd'};

    //    printf("%lu\n", sizeof(char_Array1));

    

    //    //定义字符数组的第二种方式:这种形式的赋值,默认在字符末尾插入了一个'\0','\0'是字符串结束的标志,我们在用%s作为字符数组/字符串的输出占位符时,程序会从数组的零号元素开始打印,一直打印到遇到'\0'为止

   char string[] = "hello";

    printf("%lu\n",sizeof(string));

    printf("%s\n", string);// 打印字符串使用的占位符是%s,在遇到'\0'后,会自动停止输出。

    

    

#pragma mark 字符串和字符数组的区别

   /*

     如果字符数组最后一个有效字符的末尾没有'\0',则是一个字符数组

     如果字符数组最后一个有效字符的末尾有'\0',则这个字符数组就是字符串

     */

    

#pragma mark 字符串操作函数

    // strlen():返回字符串的有效字符个数(不包括\0

    printf("string字符串的长度是%lu\n",strlen(string));

    

    // strcpy():字符串拷贝函数:把第2个参数的值拷贝给第一个参数

   char string1[10];

    strcpy(string1, string);

    printf("string1 = %s\n", string1);

    

    // strcat():字符串拼接

   char string3[20] ="hello";

   char string4[] = "world";

    strcat(string3, string4);  // string4的值,拼接到string3后边,string3必须有充足的空间盛放string4

    printf("string3 = %s\n", string3);

    

    // strcmp():字符串比较

    int b = strcmp(string3, string4);//第一个参数大于第二个参数,返回一个正整数;第一个参数小于第二个参数,返回一个负数;两个参数相等,返回0.

    //helloworld

    //world

    printf("b = %d\n",b);

    

    

    

    

    

   return 0;

}


2015-07-22 01:52:43 Dnorsunshine 阅读数 397

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——

                                    第一章 数组

一、一维数组
1、一维数组的定义

 (1)数组:相同类型的若干个数组组成一个有序的集合
 (2)一维数组:
  数组的每个元素都是基本数据类型的变量
  数组的每个元素都不是一个数组
 (3)一维数组的定义
  数组类型  数组名[数组长度]
 (4)一维数组的定义的注意事项: 
#include <stdio.h>
#define M 4
int main(int argc, const char * argv[]) {   
    //注意事项
    //(1)数组的长度是可以是一个常量 也可以是常量表达式
    int b1[1+1];  //3+3是常量表达式
    //(2)数组名的命名规则:严格按照标识符的命名规范
    //(3)数组名不能和其他变量同名
    int b2;  //这是一个整型变量
    int b2[4];//定义了一个整型数组,和整型变量同名了
    //(4)数组的长度不可以为一个变量
    int len =4;
    int b3[len];  //这是我们xcode编译器做的优化放到c++编译器就报错
    //(5)数组的长度可以使用 宏定义
    int b4[M];    //M是一个宏定义

    //(6)定义数组的时候,还可以定义普通变量
    int m,n,b5[4];  //定义两个整形变量 m,n,又定义了一个长度为4 数组名为a7的数组
    return 0;
}

2、一维数组的初始化
初始化就是给定义的变量赋值。
初始化的方法

   // 1)定义的同时进行初始化
   //   格式:
   //   数据类型 数组名[长度]={值1,值2,...};
   //   (1)定义的同时完全初始化
        //定义了一个长度为3的数组,数组名是b,给数组的每一个元素进行赋值
        int b[3]={1,2,3};
        //定义个一个数组,数组名是b1,数组的长度根据后面大括号中赋值的个数来决定的(此处大括号中有3个值,所以数组长度是3)
        int b1[]={233,45,6};
        (2)定义的同时进行部分初始化
         //定义了一个长度为3的数组,数组名是b2,给数组的元素进行赋值
        //第一种方法
        int b2[3]={6,8};   
        //第二种方法:定义一个长度为10的数组,数组名是b3,
        //[4] 表示下标为4的元素赋初值1
        //[6] 表示下标为6的元素赋初值2
        int b3[8]={[4]=1,[6]=2};
   // 2)先定义数组,然后在初始化
        int b4[4];  //定义了一个数组
        //通过下标法进行初始化,数组长度是4
        //下标是数组的元素的编号
        // 0  1  2  3
        //依次赋值
        a4[0] = 1;  
        a4[1] = 3;  
        a4[2] = 5;
        a4[3] = 7;

3、一维数组的一些问题

一维数组的初始值的问题:
(1)若未进行初始化,那么一维数组中存放的是垃圾值
(2)若只进行了部分初始化,那么其他数组元素的值为0
(3)使用先定义后初始化的方式,如果部分数组元素被初始化了,系统不会对没有初始化的那部分元素进行赋值0的操作

一维数组的访问:
数组的引用(访问):数组名[下标] 就可以访问数组的元素

数组的地址问题:
数组名是一个常量 存储的就是数组的首地址,数组名代表了数组的首地址也是数组的第一个元素的地址

一维数组长度计算:
运用sizeof函数计算

二、二维数组
1、二位数组的定义

   二维数组:
   可以看做是一个特殊的一维数组 ,这个一维数组的每个元素又是一个一维数组
   二维数组的定义
   数据类型   数组名[第一维的长度(行)][第二维的长度(列)];
   int a[2][3];
   理解方法:
   1)这是一个特殊的一维数组,一维数组有两个元素 a[0] a[1]
      a[0]  它又存放了一个长度为3的一维数组
   2)定义了一个2行3列的一个矩阵
#include <stdio.h>
#define M 3
int main(int argc, const char * argv[]) {  
    //定义一个二维数组
    int a[2][3];
    //注意事项数组名不能和变量名同名
    int b; 
    int b[2][3]; 
    //数组的长度可以是常量表达式
    int c[2][1+3];
    //注意这种写法,其他的编译器可能不支持,xcode特有的
    int m=3,n =3;
    int arr[m][n];  
    //数组长度可以使用宏定义
    int arr2[3+M][2];  
    return 0;
}    

2、二维数组的初始化

    //二维数组的初始化
    //1)定义的同时初始化  
    //(1)完全初始化
            int a1[2]={1,2};
        //1、特殊的一维数组,第一维有2个元素
            int a[2][3]={{12,23,45},{1,2,3}};  //分段
        //2、连续赋值
            int a[2][3]={1,2,3,4,5,6};
        //3、可以省略第一维
        //int a[3][3]
            int a[][3]={{1,2,3},{3,4,5},{3,4,5}}; 
        //int a[4][2]
            int a[][2]={1,2,3,4,5,6,7,8}; 
    //(2)部分初始化
        //一般情况下我们用于给数组初始化为0
             int a[3][4]={1};
             int a[3][4]={{1},{2},{3}};
        //注意:这种写法第一维长度可以省略
             int a[3][4]={1,2,3,4,5};
   //2)先定义,后初始化
         int a[3][4];
        //第一维下标:0 1 2
        //第二维下标:0 1 2 3
        a[0][0] = 1;

3、二维数组中的一些问题

二维数组的遍历
二维数组的遍历通过数组下标来访问。
二维数组的存储细节
int a[3][3]
数组的首地址 = 数组名a = &a[0] = &a[0][0]
                        第二章 指针

一、基本指针
1、指针变量的定义

(1)指针变量
 用来存放地址的变量,就是指针变量

(2)指针的实质
 就是地址

(3)指针变量的定义
 数据类型  *指针变量名;
 //定义了一个指针变量,变量名是p
 //int表示,p只能存放一个int类型的变量的地址
     int *p;   
 //定义了一个指针变量,变量名是p1
 //p1只能存放一个char类型数变量的地址
  char *p1; 
  //警告,这是不对的
  int num=10;

(4)指针变量定义的注意事项
  1)“*”  必须得有,如果没有就相当于定义一个普通变量
  2)指针变量能用来存放数值或者字符之类的吗? 不能
  3)指针变量,归根结底还是变量,也有全局和局部变量之分

2、指针变量的初始化和引用

(1)指针变量也是变量
指针变量的使用: 定义指针变量  ----> 初始化指针变量 ---> 使用(使用指针变量间接的存取内存单元的值)。

(2)指针变量如果不初始化会有什么后果?
结论:如果一个指针变量定义以后,如果不进行初始化,这个指针变量存放的事一个垃圾数,这个指针变量,称之为野指针。
一定要避免操作野指针,因为可能会带来意向不到的错误值是一垃圾值,有可能存放是系统程序的地址,可能会造成系统崩溃。

(3)"*" 的两种用法
 1) 用于定义一个指针变量
 2) 存储指针变量指向的存储空间的内容
    //指针变量如何进行初始化,指针变量应该用地址初始化
    //1、定义的同时进行初始化
    //   1)完全初始化
        //用a的地址初始化 p这个指针变量
        //另外一种描述方法:p指向了a
           int *p = &a; 
           //p1 p2都指向了a 
           int *p1 = &a,*p2 = &a; 
    //    2)部分初始化
        //定义了两个指针变量 p3 p4
           int *p3 = &b,*p4;  
           p4 = &b;
    //2)先定义后初始化
        int *p7;
        //空指针
        p7 = NULL;  
    //3)如果定义了一个指针变量,但是我不知道让这个指针指向谁
    //NULL 是空(0)
    int *p5 = NULL;  
    //空
    int *p6 = 0;     

指针的一些问题

   指针的应用场景:
   1)在被函数中可以修改主调函数中的变量的值
   2)让函数可以有多个返回值

   二级指针:
   指针存放的是另外一个指针的地址,一般形式,**p。

   指针为什么要区分类型
   因为指针存放的是地址,每一种数据类型的占用的内存字节数都不一样,所以要区分类型。

——Java培训、Android培训、iOS培训、.Net培训、期待与您交流! ——

2015-11-30 14:29:03 rui789 阅读数 181

C语言 数组

#include <stdio.h>

int main(int argc,constchar * argv[]) {

   /*

    数组的介绍:数组是一个有序排列的容器

      下标:元素的序号(位置)序号是从0开始的

    一维数组的公式:数组的数据类型名字[有多少元素]={元素,元素····};

        超出数组元素个数存取值叫做数组越界

        数组元素不够的时候系统会自动使用0补全只能少存不能多存(不能超过数组元素个数)

        元素的数据类型必须和数组的数据类型相同

    数组取值:类型变量名 = 数组名[下标];

        取出来的元素赋值给另一个变量变量类型要与数组元素类型相同

        如果元素个数不够用0补全

    数组遍历:一个个把数组里的值取出来 一般使用循环去遍历

    字符数组:char类型的数组与数字数组相同

    char 数组名[元素个数]={'元素''元素'····}

    */

#pragma mark ------1------

//    int list[5]={33,22};

//    注意:不要数组越界

//    int num=list[2];

//    printf("第三个元素:%d\n",num);

//    给数组某一个下标对应的元素赋值

//    list[3]=99;

//    printf("第四个元素:%d\n",list[3]);

#pragma mark ------2------

    //数组遍历

   //i是当做下标来用的

    /*int score[4]={98,99,100,97};

    for (int i=0; i<4; i++) {

        printf("%d位同学的成绩是:%d\n",i,score[i]);

        }

    printf("%lu\n",sizeof(score));

    printf("%lu\n",sizeof(int));

    printf("%lu\n",sizeof(score)/sizeof(int));*/

   //计算数组的元素个数:数组元素个数 =数组所占大小/元素所占大小;

    /*int list[10]={66,77,88,99};

    int count=sizeof(list)/sizeof(int);

    for (int i=0; i<count; i++) {

        printf("%d\n",list[i]);

    }*/

#pragma mark ------3------

   //往数组里面输入数据

    //初始化数组

 /*   int list[10]={};

    int num;

    //输入元素到数组的第一个位置

    printf("输入元素到数组的第一个位置:\n");

    scanf("%d",&num);

    //把输入的数字赋值给数组的第一个位置

    list[0]=num;

    //遍历一下数组

    int count=sizeof(list)/sizeof(int);

    for (int i=0; i<count; i++) {

        printf("现在数组里的下标:%d元素为:%d\n",i,list[i]);

    }*/

#pragma mark ------4------

    /*

    字符数组:char类型的数组与数字数组相同

      char 数组名[元素个数]={'元素''元素'····}

     */

    /*char name[5]={'B','r','u','c','e'};

    int count=sizeof(name)/sizeof(char);

    for (int i=0; i<count; i++) {

        printf("%c",name[i]);

    }

    printf("\n");*/

   //字符数组就相当于一个字符串

   //字符串/0结束的都是字符串 双引号""来写的都是字符串

   //单引号''引起来的是字符

    /*char name2[5]="Bruce";

    int count=sizeof(name2)/sizeof(char);

    for (int i=0; i<count; i++) {

        printf("%c",name2[i]);

    }

    printf("\n");*/

#pragma mark-------5、二维数组-------

    /*

     二维数组:大数组里面包含多个小数组(一维数组的嵌套)

     二维数组的公式:

    数据类型数组名[大数组里面小数组的个数(行)][小数组里面的元素个数(列)]={

                      {小数组里面的元素}

                      {小数组里面的元素}

                      {小数组里面的元素}

                                ····};

       举例:

        语文成绩:15450

        数学成绩:99685

        int scores[2][3]={

             {15,45,0},

             {99,68,5}};

     */

    /*int scores[2][3]={

        {15,45,0},

        {99,68,5}};

  int a= scores[0][1];

   int b= scores[1][1];

    printf("第一学期:语文成绩%d,数学成绩%d\n",scores[0][0],scores[1][0]);

    printf("第二学期:语文成绩%d,数学成绩%d\n",a,b);

    printf("第三学期:语文成绩%d,数学成绩%d\n",scores[0][2],scores[1][2]);*/

    /*int scores[2][3]={

        {15,45,0},

        {99,68,5}};

    //遍历:i最外层学科

    //    j 最里层学期

   遍历多维数组

    for循环的层数是按照表示数组范围的顺序去写for循环的层数

    循环次数是每一层的元素个数决定的

    for (int i=0; i<2; i++) {

        printf("%d\n",i+1);

        for (int j=0; j<3; j++) {

            printf("%d学期成绩为:%d\n",j+1,scores[i][j]);

        }

    }*/

//    int list[3][2]={{44,33},{55,66},{88,99}};

//    for (int i=0; i<3; i++) {

//        for (int j=0; j<2; j++) {

//            printf("%d\n",list[i][j]);

//        }

//    }

   /* int list[2][3][4]={

        {{1,2,3,4},{5,6,7,8},{0,9,6,8}},

        {{2,2,3,4},{3,2,3,4},{4,2,3,4}}};

    for (int i=0; i<2; i++) {

        for (int j=0; j<3; j++) {

            printf("\n");

            for (int k=0; k<4; k++) {

                printf("%d  ",list[i][j][k]);

            }

        }printf("\n\n");

    }*/

#pragma mark-------6、结构体-------

/*

   结构体:struct

  模型空壳子

       当想让结构体成为一个具体的东西时,只需给他赋值(给模具灌料)

   模型空壳子

       当想让结构体成为一个具体的东西时,只需给他赋值(给模具灌料)

      结构:由不同数据类型的元素(不同的原材料组成的)

      体:表示可以组成一个整体

  结构体的公式:

   struct 名字{部件;部件;部件;····};每一个部件用分号隔开

  结构体变量名.部件=;

  结构体变量名.部件2=;

   */

  /*  struct House{

        char *window;

        int door;};

    struct House dogOfHouse;

    dogOfHouse.window="落地小飘窗";

    dogOfHouse.door=1;

    printf("狗房子有一个%s的窗,有%d个门\n",dogOfHouse.window,dogOfHouse.door);*/

    typedef struct Weapon{

        char *name;

        int power;

    }Weapon;}

    return 0;

}



     

iOS——一维数组

阅读数 232

没有更多推荐了,返回首页