C 入门 第四节

unsigned char a[5] = { 12,36,96,128,182 };

练习与注意事项:

1.while循环练习题

  • 7的倍数

int a = 7;
    while (a <= 100) {
        if (a % 7 == 0) {
            printf("%d是7的倍数n",a);
        }
        a++;
    }
  • 个位为7的数

int b = 7;
    while (b <= 100) {
        if (b % 10 == 7) {
            printf("%d是个数为7的数n",b);
        }
        b++;
    }
  • 十位为7的数

int c = 0;
    while (c <= 100) {
        if (c / 10 == 7) {
            printf("%d是十为7的数n",c);
        }
        c++;
    }
  • 既不是7的倍数并且不包含7

int d = 0;
    while (d <= 100) {
        if (d % 7 != 0 && d % 10 != 7 && d / 10 != 7) {
            printf("%d既不是7的倍数并且不包含7n",d);
        }
        d++;
    }

2.判断一个数是几位数(两种方法)

  • 1️⃣

int n = 0;
    int sum = 0;
    printf("请输入任意一个数:");
    scanf("%d位",&n);
    while (n) {
        sum++;
        n /= 10;
    }
    printf("%dn",sum);
  • 2️⃣

int num = 0;
    printf("请输入一个数:");
    scanf("%d",&num);
    num = abs(num);
    int count = 1;
    int temp = num;
    while ((num /= 10) > 0) {
        count++;
    }
    //printf("%d位数n",count);
    printf("%d是%d位数n",temp,count);

3.回顾:判断质数

int num = 13;
    BOOL flag = YES;
    for (int i = 1; i <= 100; i++) {
        if (num % i == 0 && num != 1 && num != i) {
            flag = NO;
            break;
        }
    }
    if (flag) {
        printf("shi");
    } else {
        printf("bushi");
    }

4.数组

    形式1:
      int arr[5] = {1,2,3,4,5};
    形式2:(开辟5个元素大小的空间,后面元素不够的补0)
      int arr1[5] = {1,2,3};
    形式3:(如果声明一个数组没有赋初值,必须要声明数组的长度,否则会报错)
      int arr2[];
    形式4:(数组长度由后面的赋值决定)
      int arr3[] = {1,2,3,4,5};
      int a1 = arr1[3];
    //注意数组越界问题

5.数组的遍历

int numArr[] = {10, 20, 30, 40, 50};
    for (int i = 0; i < 5; i++) { //i<=length-1或i<length
        printf("%dn",numArr[i]);
    }

6.定义一个具有20个元素的整型数组,每个元素的取值范围是30-70之间,求数组元素的和

int arr[20] = {};
    int sum = 0;
    for (int i = 0; i < 20; i++) {
        arr[i] = arc4random() % (70 - 30 + 1) + 30;
        sum+=arr[i];

    }
    printf("%dn",sum);

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

int numArr[20];
    int numArr2[20];
    for (int i = 0; i < 20; i++) {
        numArr2[i] = numArr[i];
    }
    for (int i = 0; i < 20; i++) {
        printf("%dn",numArr2[i]);

    }

8.对存储十个整型元素的数组随机赋值(20-30),计算最大值和所有元素和

int arr[10];
    int max = 0;
    int sum = 0;
    for (int i = 0; i < 10; i++) {
        arr[i] = arc4random() % (30 - 20 + 1) + 20;
        max = max > arr[i] ? max : arr[i];
        sum += arr[i];

    }
    printf("max=%dn",max);

9.生成两个数组,每个数组都有10个元素,元素取值范围20-40之间,数组对应元素相加,放到另外一个数组中

int arr1[10];
    int arr2[10];
    int arr3[10];
    for (int i = 0; i < 10; i++) {
        arr1[i] = arc4random() % (40 - 20 + 1) + 20;
        arr2[i] = arr1[i];
        arr3[i] = arr1[i] + arr2[i];
        printf("%dn",arr3[i]);
    }

10.整型数组的长度20,随机数范围35-90,找到数组中最大的元素的值和它所对应的下标

int array[20];
    int max = 0;
    int maxIndex = 0;
    for (int i = 0; i < 20; i++) {
        array[i] = arc4random() % (90 - 35 + 1) + 35;
        //max = max > array[i] ? max : array[i];
        if (max < array[i]) {
            max = array[i];
            maxIndex = i;  //存i的值
        }
    }
printf("最大值为:%dn",max);
printf("最大值的下标为:%dn",maxIndex);

11.冒泡排序法(一)

//需要比length-1次
    int numbers[] = {6, 2, 8, 3, 9, 7};
    BOOL flag = YES; 
    for (int j = 0; j < 6 - 1 && flag == YES; j++) {
        flag = NO;
        for (int i = 0; i < 6 - 1 - j; i++) { //6-1不需要访问最后一个了
            if (numbers[i] > numbers[i + 1]) {
                int temp = numbers[i + 1];
                numbers[i + 1] = numbers[i];
                numbers[i] = temp;
                flag = YES;
            }
        }
    }

    //进行遍历
    for (int i = 0; i < 6; i++) {
        printf("%dn",numbers[i]);
    }

12.冒泡排序法(二)

    int n[] = {124,76,78,35,9,21,76,12};
    //sizeof查看所占空间大小
    int count = sizeof(n) / sizeof(n[0]);
    BOOL f = YES;
    for (int j = 0; j < count - 1 && f == YES; j++) {
        f = NO;
        for (int i = 0; i < count - 1 - j; i++) {
            if (n[i] > n[i + 1]) {
                int t = n[i + 1];
                n[i + 1] = n[i];
                n[i] = t;
                f = YES;
            }
        }
    }

    for (int i = 0; i < count; i++) {
        printf("%dn",n[i]);
    }

13.字符串&字符数组

    char str1[] = {'a','b','c'}; //字符数组
    char str2[] = "abc"; //字符串
    char str3[] = {'a','b','c',''}; //字符串
    printf("%sn",str3);

//strlen()计算字符串长度
    unsigned long len = strlen(str2);
    printf("字符串长度为:%lun",len);

//strcpy()字符串拷贝
    char str5[] = "haha";
    unsigned long len1 = strlen(str5);
    char str4[len1 + 1];
    strcpy(str4, str5);
    printf("拷贝结果是:%sn",str4);

//strcat()字符串拼接
    char str6[20] = "ni";
    //unsigned long len2 = strlen(str6);
    char str7[] = "sha";
    strcat(str6, str7);
    printf("字符串拼接后是:%sn",str6);

//strcmp()字符串比较
    char str8[] = "lala";
    char str9[] = "luelue";
    int result = strcmp(str8, str9);
    printf("较大的是:%dn",result);

14.对查找字符串的空格数:例如:“I love iOS”

char string[] = "I love iOS";
    int count = 0;
    int kongge = 0;
    while (string[count] != '') {
        if (' ' == string[count]) {
            kongge++;
        }
        count++;
    }
    printf("空格数:%dn",kongge);

C# 类型体系包含下列3种类型:

/*
    1. 数组属于构造类型
    2. 具有相同数据类型成员数组的一组数据
    3.
存储不同类型数据的数据有对应的名称,整形数组;数组中成员变过来都整型的;浮点型数组:数组中成员变量都浮点型的
    4. 数组是由多个成员组成,每个成员被称为数组元素
 
    定义数组
    类型修饰符 数组名[常量表达式] = [值1, 值2, 值3];
    1. 类型修饰符: 指定数组中元素的类型
    2.
[]中设定数组元素的个数,即数组的存储空间.只能是常量表达式,不能是变量表达式.
    3. 初始值之间用,隔开
    4. 定义一个整型数组,存放( ⊙ o ⊙ )3个数组元素 2, 3, 4
    
    int a[3] = {1, 3, 4,};
    float a[5] = {1, 2, 3, 4, 5};
 
    定义数组的方式 1:没有赋值初始的元素,自动设置初始值为0;
    int b[5] = {3, 4, 5};
    
    定义数组方式 2:
    int c[3] = {0};
        
    定义数组方式 3:根据初始化设置,判断数组元素个数
    int d[] = {3, 4, 5, 6};
 
    错误的 定义数组方式 1 :指定的数组元素个数<设定初始值的数量
    int e[2] = {3, 4, 5,6};
 
    错误的 定义数组方式 2: 既没有指定元素个数, 也没有赋值初始值
    int f[] = {0};
 
    定义数组后, 数组的存储空间是连续的
    数组的存储空间 = 数组元素的个数*元素占的字节
    
    printf(“%lun”,sizeof(e));
 
 访问数组元素
    1.
不能一次整体调用整个数组全部元素的值,基本数据类型变量中值存储一个数据.数据中存储多个数据,不能通过数组变过来调用所有的元素.
    2. 访问数组元素 使用下标实现 数组名[下标]
    3. 下标: 数组元素在数组中序号,数组中的元素是有序的,
每个元素都有序号,序号从0开始递增, 最后一个元素的序号是 n-1,
n表示数组元素的个数
    4. 下标的范围: 0~n-1
    5. 下标可以用整型常量或变量表示
 
 遍历数组
    1. 按照顺序,从数组的第一个元素开始,访问数组的最后一个元素结束
    2. 使用for循环实现数组遍历
    3.循环和数组关系密切
 */
 /*
    int age[5] = {18,15,23,28,21};
    printf(“%dn”,age[0]);
    
    for (int i = 0; i < 5; i ++)
    {
        printf(“%d “,age[i]);
    }
 
// 修改数组元素:根据数组下标确定需要修改的数组元素
    int aa[] = {1,2,3,4,6};
//遍历数组
    for (int i = 0; i <5; i ++)
    {
        printf(“%d “,aa[i]);
    }
//修改数组元素
    aa[1] = 22;
    aa[3] = 44;
    for (int j = 0; j < 5; j ++)
    {
        printf(“%d “,aa[j]);
    }

 a[]范围为0~256. 数组中数都有效。

知识点:

1.数组

1️⃣数组:
  由相同数据类型组成的构造类型,每个成员称为一个数组元素。
  最简单的数组是一维数组。
2️⃣定义:
  类型说明符 数组名[常量表达式] = {值1,值2...};
一维数组定义:
  数据类型 数组名称[元素个数];
  int arges = [10];
3️⃣数组初始化:
  数组元素的访问:数组名 + 下标
4️⃣数组下标:数组元素在数组中的序号。
5️⃣下标可以是常量,也可以是变量。
6️⃣访问数组中的元素下标可以为变量。
7️⃣访问数组中的所有元素叫遍历。
8️⃣系统不会检测数组元素的下标是否越界,编程时,必须保证数组下标不能越界。
9️⃣不能这样定义数组:
  int array[] = {}; 或者 int array[2] = {1, 2, 3};
🔟数组是一个整体,不能直接参加运算,只能对单个元素进行处理,通常用到数组的地方都会用到循环。

2.冒泡排序

1️⃣使用数组时,很多时候需要将数组中的元素按照一定条件进行排序。
2️⃣冒泡排序 是比较常见的排序算法。
3️⃣因为其原理跟水底气泡上升至水面很相似而得名。
4️⃣冒泡排序涉及到双循环,外层循环控制趟数,内层循环控制比较次数。

3.操作字符数组的函数:

1️⃣''结束标识的字符数组也称为字符串。
2️⃣系统提供了很多字符串处理函数:
    strlen()  计算字符串长度
    strcpy()  字符串拷贝
    strcat()  字符串拼接
    strcmp()  字符串比较
3️⃣字符串所占的空间 至少要比 字符串长度大1,因为字符串结尾默认有’’,占一个字节, 系统提供的字符串处理函数都是根据  ‘’  来判断字符串是否结束。
4️⃣在printf输出字符串时,占位符用%s。

3-1值类型————-简单值类型:数值类型、布尔类型、字符类型、自定义类型

//   通过循环方式给数组元素赋值
//    1. 定义一个数组, 必须设置数组元素数量, 数组元素初值为0
//    2. 透过循环给数组元素赋值
    
    int num[5] = {0};
//  在 0 ~ 10 之间取随机数,分别赋给每个元素
    for (int i = 0; i < 5; i ++)
    {
        num[i] = arc4random()%(10 – 0 + 1) + 0;
        printf(“%d “,num[i]);
    }

char a[5] = { 12,36,96,128,182 };

作业:

1.随机输入一个年份,判断该年份是否是闰年?如果是闰年,则输出该年是闰年,否则输出该年不是闰年。
满足闰年的条件:

  • 能被400整除。(如2000年是闰年,1900年不是闰年)。
  • 能被4整除,但是不能被100整除。(如2004年就是闰年,2010年不是闰年).

int year = 0;
    printf("请输入一个年份:");
    scanf("%d",&year);
    if ((year % 400 == 0) || (year % 4 == 0 && year % 100 != 0)) {
        printf("%d是闰年n",year);
    } else {
        printf("%d不是闰年n",year);
    }

2.已知abc+cba =
1333,其中a、b、c均为一位数,编程求出满足条件的a、b、c所有组合。

for (int a = 1; a < 10; a++) {
        for (int b = 0; b < 10; b++) {
            for (int c = 1; c < 10; c++) {
                if ((a * 100 + b * 10 + c * 1) + (c * 100 + b * 10 + a * 1 == 1333)) {
                    printf("%d,%d,%dn",a,b,c);
                }
            }
        }
    }

3.随机产生20个10~50的正整数存放到数组中,并求数组中的最大值,最小值,平均值及各个元素之和

    int num[20];
    int max = 0;
    int min = 0;
    int avr = 0;
    int sum = 0;
    for (int i = 0; i < 20 - 1; i++) {
        num[i] = arc4random() % (50 - 10 + 1) + 10;
        max = max > num[i] ? max : num[i];
        min = min < num[i] ? min : num[i];
        avr = num[i]/20;
        sum+=num[i];
    }
    printf("最大值为:%dn",max);
    printf("最小值为:%dn",min);
    printf("平均值为:%dn",avr);
    printf("元素和为:%dn",sum);

4.编写一个程序,输入两个包含5个元素的数组,先将两个数组升序排列,然后将这两个数组合并成一个升序数组

int arr1[] = {1, 5, 8, 14, 7};
    int arr2[] = {3, 6, 34, 29, 4};
    int arr3[11] = {};
    BOOL flag = YES;
    for (int j = 0; j < 5 - 1; j++) {
        flag = NO;
        for (int i = 0; i < 5 - 1 - j; i++) {
            if (arr1[i] > arr1[i + 1]) {
                int temp = arr1[i + 1];
                arr1[i + 1] = arr1[i];
                arr1[i] = temp;
                flag = YES;
            }
        }
    }
    for (int i = 0; i < 5; i++) {
        printf("数组一:%dn",arr1[i]);
    }



    for (int j = 0; j < 5 - 1; j++) {
        flag = NO;
        for (int i = 0; i < 5 - 1 - j; i++) {
            if (arr2[i] > arr2[i + 1]) {
                int temp = arr2[i + 1];
                arr2[i + 1] = arr2[i];
                arr2[i] = temp;
                flag = YES;
            }
        }
    }
    for (int i = 0; i < 5; i++) {
        printf("数组二:%dn",arr2[i]);
    }



    for (int i = 0; i < 5; i++) {
        arr3[i] = arr1[i];
        arr3[i] = arr2[i - 5];
    }
    for (int j = 0; j < 10 - 1; j++) {
        flag = NO;
        for (int i = 0; i < 10 - 1 - j; i++) {
            if (arr3[i] > arr3[i + 1]) {
                int temp = arr3[i + 1];
                arr3[i + 1] = arr3[i];
                arr3[i] = temp;
                flag = YES;
            }
        }
    }
    for (int i = 0; i < 10; i++) {
        printf("数组三:%dn",arr3[i]);
    }

5.给定某年某月某日,输出其为这一年的第几天

    int dayArr[] = {31, 28, 31, 28, 31, 30, 31, 31, 29, 31, 30, 31}; //先确定每个月有多少天
    int year1 = 0;
    int month = 0;
    int day = 0;
    printf("请输入一个年份:");
        scanf("%d",&year);
        if ((year1 % 400 == 0) || (year1 % 4 == 0 && year1 % 100 != 0)) {
            printf("%d是闰年n",year1);
            dayArr[2] = 29;
        }
    for (int i = 0; i < month - 1; i++) {
        day += dayArr[i];
    }
    printf("第%dn天",day + month);

6.编写整型数组排序程序(冒泡排序-升序)

    int array[] = {2,56,97,23,17,7,45};
    BOOL f = YES;
    for (int j = 0; j < 7 - 1; j++) {
        f = NO;
        for (int i = 0; i < 7 - 1 - j; i++) {
            if (array[i] < array[i + 1]) {
                int temp = array[i + 1];
                array[i + 1] = array[i];
                array[i] = temp;
                f = YES;
            }
        }
    }

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

7.找出下列整型数组中的最大和最小值及其所在位置的下标i
int a[] = {5, -9, 32, 77, 64, -24, 14, 0, 21, 45};

    int a[] = {5, -9, 32, 77, 64, -24, 14, 0, 21, 45};
    int max1 = 0;
    int min1 = 0;
    int maxIndex = 0;
    int minIndex = 0;
    for (int i = 0; i < 10 - 1; i++) {
        if (max1 < a[i]) {
            max1 = a[i];
            maxIndex = i;
        }

    }

    for (int i = 0; i < 10 - 1; i++) {
        if (min1 > a[i]) {
            min1 = a[i];
            minIndex = i;
        }
    }
    printf("最大值是:%dn,最小值是:%dn",max1,min1);
    printf("最大值所在位置的下标是:%dn,最小值所在的下标是:%dn",maxIndex,minIndex);

8.把 str1, str2, str3 合并到 result 数组中。
char result[50] = {0};
char str1[] = “Lanou “;
char str2[] = “23_class “;
char str3[] = ” is niu best!”;
结果:“Lanou 23_class is niu best!”

char result[50] = {0};
    char str1[] = "Lanou ";
    char str2[] = "23_class ";
    char str3[] = " is niu best!";
    strcat(str1, str2);
    strcat(str1, str3);
    strcat(result, str1);
    printf("%sn",result);

9.删除字符串中含有0-9的数字

char str[] = "a34sf5slvjxz2g";
  int count = 0;
  int index = 0;  //记录位置
  while (str[count] != '') {
      if ('0' <= str[count] && str[count] <= '9') {
          count++;
          continue; //往下继续遍历
      }
      str[index] = str[count];
      index++;
      count++;
  }
  str[index] = '';
  printf("%sn",str);

                 ————-复合值类型:

// 定义一个具有10个元素的整型数组,每个元素的值在30 ~ 80之间取随机数.
    
    int num[10] = {0};
    for (int i = 0; i < 10; i ++)
    {
        num[i] = arc4random()%(80 – 30 + 1) + 30;
        printf(“%d “,num[i]);
    }

a[]范围为-128~127. 数组中128和182均无效。

                                                       
struct结构{数值类型、布尔类型、自定义类型}

//越界
//    1. 使用数组下标是,超出下标范围.
//    2. 数组越界很危险,一旦越界, 即访问了不属于数组的存储空间
//    3. 编译器不会检测数组下标是否越界,因此操作数组是必须保证没有越界
//
    int Crazy[4] = {3,4,5,6};
    printf(“%d “,Crazy[4]);
    
    注意事项:
    定义数组  类型 数组名[元素个数]
C 入门 第四节。    数组元素      数组名

                                                          enum枚举

    int c = 0;
    int a[5] = {1,2,3,4,5};
    int b[5] = {0};
    for (int i = 0; i < 5; i++)
    {
        c = a[i];
        b[i] = c;
        printf(“%d “,b[i]);
    }
    printf(“n”);
*/
    
#pragma mark  ——数组排序——–
 /*
    1. 常见的排序方法:冒泡排序,选择排序.插入排序等
    2. 排序的规律有俩种:升序, 降序
    3. 本节课: 冒泡排序
    4.
冒泡排序的思路:每次将相邻的俩个数进行比较,按照升序或降序进行交换,直到所有数字的顺序正确为止

3-2引用类型–          class类

    int a[5] = {5, 4, 3, 2, 1};
    for (int i = 0; i < 5; i ++)  //外循环,控制循环排序趟数;5
    {
        for (int j= 0; j < 5 – i;j ++) //内循环,控制比较次数
        {
            if (a[j] > a[j + 1])
            {
                int temp = a[j];
                a[j] = a[j + 1];
                a[j + 1]= temp;
            }
        }
    }
    for (int i = 0; i < 5; i++)
    {
        printf(“%d “,a[i]);
    }

                                   interface接口

//        随机产⽣生10个[20,40]数,并对10个数从⼩小到⼤大排序
    int a[10] = {0};
    for (int i = 0; i < 10; i ++)
    {
        a[i] = arc4random()%(40 – 20 + 1) + 20;
        //    printf(“%d “,a[i]);
    }
    printf(“n”);
    for (int j = 0; j < 10 – 1; j ++)
    {
        for (int z = 0; z < 10- j – 1; z ++)
        {
            int temp;
            if (a[z] > a[z + 1])
            {
                temp = a[z];
                a[z] = a[z + 1];
                a[z + 1] = temp;
            }
        }
    }
    for (int i = 0;i < 10; i ++)
    {
        printf(“%d “,a[i]);
    }
*/  
#pragma mark  ——–字符数组——–
//    1. 数组元素存储的是字符.
//    定义字符数组
/*
    char a[5] = {‘h’,’e’,’l’,’l’,’o’};
    char b[] = {‘h’,’e’,’l’,’l’,’o’};
    char c[10] = {‘h’,’e’,’l’,’l’,’o’};
    a[3] = ‘t’;   //修改
    printf(“%cn”,a[3]);   //访问

                                   delegate委托

// 字符串
    定义字符数组存储字符串
    char a[] = “hello”;
    char b[] = {‘h’,’e’,’l’,’l’,’o’,’’}; //有 是字符串 
没有是数组
      
    1 . 字符串常量 “hello”
    2 . 使用字符数组存储字符串
    3 . 使用%s, 输出字符串
    
    定义字符数组存储字符串
    1 . char a2[] = “hello”;
    系统如何识别字符串: ‘’ 
数据存储在内存中,系统如何识别那先字符属于一个完整的字符串
    ‘’是字符串结束标志,在字符串的最后一位,由系统默认添加,不可以显示
    “hello”存储时,实际上是: ‘h’,’e’,’l’,’l’,’o’,’’
    有效字符: 在字符串中,’’之前的字符
    字符数组a2中存储字符串: 数组元素为 ‘h’,’e’,’l’,’l’,’o’,’’
    存储字符串的字符数组元素个数: 有效字符个数  + 1
    输出字符串: printf(“%s”,a2)
   
    字符串和字符数组的关系
    1 .字符串是一个字符数组
    char p[] = “hello” //字符串
    char q[] = {‘h’,’e’,’l’,’l’,’o’} //数组
    p  q  都是数组
    俩个数组存储的内容都是  字符串hello
    都可以访问,修改数组元素,遍历
    for (int i; i < sizeof(p)/sizeof(char); i ++)
    {
        printf(“%c “,p[i]);
    }
    
    2 . 字符数组不一定是字符串但是字符串一定是字符数组.
    3 .
存储字符串的数组,可以输出单个字符,也可以使用%输出完整字符串,使用%s输出时,遇到’’是结束
    char a3[] = {‘h’,’e’,’l’,’l’,’o’,’’};
    printf(“%s “,a3);
    
    4 . 字符数组储存字符的数组, 只能输出单个字符
    char a4[] = {‘h’,’e’,’l’,’l’,’o’,’’};
    for (int i; i < sizeof(a4) / sizeof(char); i ++)
    {
        printf(“=====%c “,a4[i]);
    }
    printf(“n”);
    printf(“+++++++%s “,a4);
//输出结果可能出问题,因为不知道什么时候才能读到’0′
*/
#pragma mark ——字符串操作函数———
/*
1 . strlen 测量字符串常量.
    测量的是字符串的时间长度,不包含’/0′

                             – – -array数组

    char name[] = “wangshuai”;
    printf(“%s的长度;%lun”,name,strlen(name));
    
//2 . strcpy 字符串拷贝
    字符串2可以是常量,字符数组名
    字符数组1的存储空间 >= 字符数组2  注意’’
   
牢记:吧一个字符数组的值给另一个字符赋值,只能用strcpy函数,不能直接堆一个字符数组赋值
    char a12[5] = {0};
    char b12[] = “lanou”;
    strcpy(a12, b12);
    printf(“%sn”,a12);
 
*/
/*
    char a22[30] = “lanou”;
    char b22[] = “teacher”;
3 .strcat(a22, b22);
    //将字符串2拼接到字符串1后,结果保留在字符串1中
    //字符数组2可以是常量
    //字符数组1的空间必须足够大
    //拼接之后,字符串1后面的’’取消,只在新的字符串后面保留’’
    printf(“%sn”,a22);
4 . strcmp 字符串比较
    char a[] = “apple”;
    char b[] = “goole”;
   
//将俩个字符串自左向右逐个字符相比(按ASDII吗值大小比较),直到出现不同的字符或者是遇到’’为止
    //字符串1的字符 – 字符串2的字符
    //字符串1 = 字符串2,则函数结果为0
    //字符串1 > 字符串2,则函数结果为正整数
    //字符串1 < 字符串2,则函数结果为负整数
    printf(“%dn”,strcmp(a, b));
    printf(“%dn”,strcmp(“apple”, “apple”));
    //查找字符串中的空格:例如:”I LOVE iOS, i want iphone6sp”
    char str[] = “I LOVE iOS, i want iphone6sp”;
    int nn = 0;
    int count = 0;
    while (str[nn])
    {
        if (str[nn] != ‘0’)
        {       
        count ++;
        }  
    nn ++;
    }
    printf(“空格数是:%dn”,count);
*/

                                 
 内置引用类型:(dynamic动态)、object对象、string字符串

3-3指针类型

C#的数据类型可以分为3类:数值类型,引用类型,指针类型。指针类型仅在不安全代码中使用。

值类型包括简单值类型和复合型类型。简单值类型可以再细分为整数类型、字符类型、实数类型和布尔类型;而复合类型则是简单类型的复合,包括结构(struct)类型和枚举(enum)类型。

值类型包括简单类型(如字符型,浮点型和整数型等),集合类型和结构型。引用类型包括类类型,接口类型,代表类型和数组类型。

值类型和引用类型的不同之处是值类型的变量值直接包含数据,而引用类型的变量把它们的引用存储在对象中。对于引用类型的变量,完全有可能让两个不同的变量引用同一个对象,这样一来,对其中一个变量的操作就会影响到被另一个变量引用的对象。对于值类型的变量而言,每一个变量有它们自己的数值,因此对其中一个变量的操作不可能影响到另外一个变量。

1 值类型

所有的值类型都隐含地声明了一个公共的无参数的构造函数,这个构造函数叫做默认构造函数。默认构造函数返回一个初始为零的值类型的实例,称之为默认值。

对于sbyte,byte,short,ushort,int,uint,long,ulong,默认值为0。

对于char,默认值是’x0000′

对于float,默认值是0。0F

对于double,默认值是0。0D

对于decimal,默认值是0。0M

对于bool,默认值是false

对于一个枚举类型,默认值是0

对于一个结构类型,默认值的设置就是把所有值类型的域都设置为它们各自的默认值,把所有的引用类型的域赋为空

1.1 简单类型

C#提供一套预定义的结构类型叫做简单类型。简单类型用保留字定义,这些保留字仅仅是在System名字空间里预定义的结构类型的化名。比如int是保留字,System。Int32是在System名字空间中预定义类型。一个简单类型和它化名的结构类型是完全一样的,也就是说写int和写System。Int32是一样的。简单类型主要有整型,浮点类型,小数类型,布尔类型,字符型

1.1.1 整型

C#中支持9种整型:sbyte,byte,short,ushort,int,uint,long,ulong和char。

Sbyte:代表有符号的8位整数,数值范围从-128 ~ 127

Byte:代表无符号的8位整数,数值范围从0~255

Short:代表有符号的16位整数,范围从-32768 ~ 32767

ushort:代表有符号的16位整数,范围从-32768 ~ 32767

Int:代表有符号的32位整数,范围从-2147483648 ~ 2147483648

uint:代表无符号的32位整数,范围从0 ~ 4294967295

Long:代表有符号的64位整数,范围从-9223372036854775808 ~
9223372036854775808

Ulong:代表无符号的64位整数,范围从0 ~ 18446744073709551615。

char:代表无符号的16位整数,数值范围从0~65535。

Char类型的可能值对应于统一字符编码标准(Unicode)的字符集。

Char类型与其他整数类型相比有以下两点不同之处:

a,没有其他类型到char类型的隐式转换。即使是对于sbyte,byte和ushort这样能完全使用char类型代表其值的类型,
sbyte,byte和ushort到char的隐式转换也不存在。

b,char类型的常量必须被写为字符形式,如果用整数形式,则必须带有类型转换前缀。比如(char)10赋值形式有三种:

char chsomechar=”A”;

char chsomechar=”x0065″; 十六进制

char chsomechar=”u0065 ; unicode表示法

字符型中有下列转义符:

1,’用来表示单引号

2,”用来表示双引号

3,\ 用来表示反斜杠

4, 表示空字符

5, a 用来表示感叹号

6, b 用来表示退格

7, f 用来表示换页

8, n 用来表示换行

9, r 用来表示回车

10, t 用来表示水平tab

11, v 用来表示垂直tab

1.1.2 浮点类型

C#支持两种浮点类型:float和double。

Float型所能表示的值的范围大约可以从1.5*10 -45~3.4* 10
38,精确到小数点后面7位。

Double型所能表示的值的范围大约可以从5.0*10 -324~1.7* 10
308,精确到小数点后面15位或16位。

如果二元操作中的其中一个操作数为浮点类型,那么另外一个操作数是整型或浮点类型,运算规则如下:

a,如果其中一个操作数是整型,则操作数被转换为另一个操作数的浮点数类型;

b,如果操作数之一为double,则另一操作数也被转换成double类型,运算以double类型的精度和取值范围进行,并且所得结果也为double类型;

c,否则,运算至少将以float类型的取值范围和精度进行,并且所得结果也为float型。

1.1.3 小数(decimal)类型

小数类型非常适用于金融和货币运算。数值范围从1.0*10 -28~7.9* 10
28,精确到小数点后面28位。如果二元操作中的其中一个操作数是小数类型,那么另外一个从操作数是整型或小数类型。整型在运算前被转化为小数类型数。如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太小的值,操作的结果将会变成0。如果一个小数类型的算术运算产生了一个对于小数类型的格式来说太大的值,就会触发溢出错误。小数类型较浮点类型而言,具有更大的精确度,但是数值范围相对小了很多。将浮点类型的数向小数类型的数转化时会产生溢出错误,将小数类型的数向浮点类型的数转化时会造成精确度的损失。因此,两种类型不存在隐式或显式转换。布尔型:值为true或false。没有标准能实现布尔类型和其他类型的转换。

1.2 枚举类型

枚举类型的元素使用的类型只能是long,int,short,byte。默认类型是int。默认第一个元素的值是0,每一个连续的元素按1递增。可以给元素直接赋值。如:

[csharp] view plain copy print?

enum monthnames

{

January=1,

February,

march=31

};

可以强制定义其他类型,如:

enum monthnames : byte

{January ,

February,

March

};

1.3结构类型

结构类型也是一种值类型,使用它的目的是用于创建小型的对象,用以节省内存。下面的例子表示一个使用byte类型的4个字段的IP地址。

[csharp] view plain copy print?

using System;

Struct IP //声明结构

{

public byte b1,b2,b3,b4;

}

Class test

{

public static void Main()

{

IP myIP;

myIP.b1=192;

myIP.b2=168;

myIP.b3=1;

myIP.b4=101;

Console.Write(“{0}.{1}。”, myIP.b1, myIP.b2);

Console.Write(“{0}.{1}”, myIP.b3, myIP.b4);

}

}

2 引用类型

引用类型包括类类型,接口类型,代表类型和数组类型。

2.1 类类型


类型定义了一种数据结构,这个数据结构中包含了数据成员(如常量,字段和事件等),函数成员(如方法,属性,索引,操作,构造函数和析构函数等)和嵌套
类型。支持继承。

2.2 对象类型

对象类型是其他所有类型最终的基础类型。在C#中每一种类型都直接或者间接的源于object这个类类型。

2.3 字符串类型

字符串类型是直接从object中继承而来的密封类。String类型的值可以写成字符串文字的形式。

2.4 接口类型

一个接口声明一个只有抽象成员的引用类型,接口仅仅存在方法标志,但没有执行代码。当定义一个类时,如果类从接口派生,可以派生自多重接口;但是如果类从类派生,就只能从一个类派生。

声明方法如例:

[html] view plain copy print?

interface iface

{

void showmyface();

}

2.5 代表类型

代表引用一种静态的方法或者对象实例,引用该对象的实例方法。与其接近的是c/c++中的指针,但指针只能访问静态的函数,代表既能访问静态的方法,也能访问实例的方法。

2.6 数组

数组是包含一串变量的数据结构。数组变量也称做数组元素,它们具有相同的类型,这种类型也称做数组元素类型。数组的元素类型可以是任何类型,包括数组类型。数组用下标确定每一个数组元素的索引号。只有一个下标的数组称为一维数组,多于一个下标的数组称为

多维数组。

例:int[] a={0,2,4,6,8}; 等价于int[] a=new int[]
{0,2,4,6,8};

也可以这样初始化:a[0]=0; a[1]=2; a[2]=4; a[3]=6; a[4]=8;

int[] a; //int型的一维数组

int[,] a; //int型的二维数组

int[,,] a; //int型的三维数组

int[] []a; //int型的数组的数组

int[][][]a; //int型的数组的数组的数组

数组的每个维数的长度不是数组类型的一部分,维数的长度是在数组创建语句中指定的,而不是在数组类型中

指定的,例如:

int[,,] a3=new int[10,20,30];

a3是是一个数组变量, int[,,] 没有指定数组的长度,数组创建语句new
int[10,20,30]才指定。

下面的例子创建一个数组的数组:

int[][] J=new int[3][];

J[0]=new int[] {1,2,3};

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

J[2]=new int[] {1,2,3,4,5,6,7,8,9};

原文地址: