c16---字符串

//
//  main.c
//  字符串的基本概念,字符串和字符数组的共用的char[],

#include <stdio.h>

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

    // 用双引号引起来的就是字符串
    printf("Hello, World!\n");

    // 如何定义字符串变量, 由于字符串是同一种类型的数据组成,  并且是有序的\
    而数组就是用于存储很多同一种类型的有序数据, 所以可以使用数组来保存字符串

    // 注意: 字符串变量和普通的字符数组有一定的区别
    // C语言规定, 字符串必须以\0结尾(作为字符串的结束符号), 所以字符串变量的元素个数比字符数组的元素个数多一个 \0
    char str[] = "lnj"; // 字符串变量 l n j \0
    printf("str size = %lu\n", sizeof(str));//

    char charValues[] = {'l', 'n', 'j'}; // 字符数组 , 这个并不是字符串, 而是字符数组
    printf("charValues size = %lu\n", sizeof(charValues));//

    int num = ;
    float floatValue = 10.1f;
    double doubleValue = 9.9;
    char  charValue = 'm';
    printf("%i, %f, %lf, %c\n", num, floatValue, doubleValue, charValue);//10,10.100000,9.900000,m

    // 内存寻址从大到小
    char str[] = "lnj"; // 字符串变量
    char str2[] = {'x', '\0' ,'m', 'g'}; // 字符数组

    // 如何输出字符串变量, %s
    // str 数组的名称, 数组的名称就是数组的地址
    // %s的原理, 从传入的"地址"开始逐个取出, 直到遇到"\0"位置
    printf("str = %s\n", str2); // x,

    // 字符串注意点, 字符串的初始化
    char str1[] = "lnj";
    char str2[] = {'l', 'n', 'j', '\0'};
      printf("str = %s\n", str2); // lnj
    // 部分初始化, 部分初始化中, 没有被初始化的元素默认是0
    // \0对应的ASCII 0
    char str3[] =  {'l', 'n', 'j'}; // l n j 0000000

    char str4[] = {'l', 'n', 'j'}; // 该方式不是字符串, 而是字符数组, 因为没有\0，字符串和字符数组的共用的char[],
    char str5[] = {'l', 'n', 'j'}; // 错误写法

    // 需要明白的一点就是字符串以\0结尾, 没有\0就不是字符串
    // 只要是用双引号括起来的都是字符串
    // 字符串的本质就是数组
    char str6[] = "lnj";
    str6[] = 'y';

    printf("%s", str6);

    return ;
}

//
//  main.c
//  字符串常用方法1
//
//  Created by xiaomage on 15/6/12.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>
#include <string.h>
int myStrlen(char str[]);
int myStrlen2(char str[], int length);

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

    // 1.如何输出字符串
    // 1.1可以使用printf的%s占位符来输出
    // 弊端 : 如果想要换行, 必须加上\n
    // 优点 : 可以自定义格式化需要输出的字符串, 也就是可以按照我们需要的格式来输出
    char str[] = "lnj";
    printf("name = %s!!!!\n", str);
    printf("-------\n");

    // 1.2可以使用puts函数来输出
    // 优点: 可以自动换行
    // 缺点: 不可以自定义格式, 只能原样输出
    puts(str);
    printf("-------\n");

    // 2.如何输入字符
    // 2.1利用scanf接收字符串的注意点
    // scanf接收字符串, 会以空格 , tab, 回车作为结束符号, 也就是说利用scanf接收字符串时, 字符串中不能出现空格, tab, 回车
    printf("请输入一个字符串\n");
    char buf[];
    scanf("%s", buf);
    printf("buf = %s\n", buf);
    printf("-------\n");

    // 2.2利用gets接收字符串
    // warning: this program uses gets(), which is unsafe.
    // 如果使用gets接收字符串, 系统会提示我们正在使用一个不安全的方法接收字符
    // 优点: 如果利用gets接收字符串 , 可以在字符串中输入空格, tab
    printf("请输入一个字符串\n");
    char buf2[]; // lnj c
    gets(buf2);
    printf("buf = %s\n", buf2);
    printf("-------\n");

    // 3.如何计算字符串的长度
    //            0123
    char str[] = "lnj cool"; //
    int length = sizeof(str) / sizeof(str[]) - ;
    // strlen的原理: 从传入的地址开始逐个取出字符串, 每取出一个就让计数器+1. 直到遇到\0为止
    size_t size =  strlen(str); // 计算出来的结果不包括\0
    int size = myStrlen(str);
    int length = sizeof(str) / sizeof(str[]);
    int size = myStrlen2(str, length);

    printf("length = %lu\n", size);
    for (int i = ; i < size; i++) {
        printf("str[%i] = %c\n", i , str[i]);
    }
    return ;
}

int myStrlen2(char str[], int length)
{
    // 1.定义变量记录取出了多少个字符
    int count = ;
    // 2.遍历字符数组
    for (int i = ; i < length; i++) {
        if (str[i] != '\0') {
            count++;
        }
    }
    return count;
}

// 自定义一个strlen函数
int myStrlen(char str[])
{
   // 1.定义变量记录取出了多少个字符
    int count = ;
  // 2.遍历字符数组
    while (str[count] != '\0') {
        count++; // 1 2 3
    }
    return count;
}

//
//  main.m
//  字符串常用方法2
//
//  Created by xiaomage on 15/6/12.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

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

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

    // 1.字符串拼接
     // 原理 : 首先遍历第一个字符串,直到遇到\0为止, 然后取出第二个字符串中的字符, 从\0的位置开始添加, 添加完毕之后再在最后添加一个\0

    char str1[] = "lnj"; // l n j c o o l \0
    char str2[] = " cool";
    printf("拼接前: %s\n", str1);
    // dest : 目标 src : 源
    // 将src中的数据拼接到dest后面
    // 注意: 要想使用字符串拼接函数, 那么dest必须是一个数组, 并且数组的长度必须大于拼接之后的长度 \
    如果dest数组的长度, 不能完全存放dest+src+\, 那么就会报错
    strcat(str1, str2);

    // char * 相当于dest  const char * 相当于src size_t 需要拼接的个数
    // 为了避免拼接之后超出str1的存储范围, 那么可以动态计算str2中需要拷贝几个到str1后面不会超出
//                  str1能够存放的元素个数            -   str1已经存放的个数  - \0
    size_t length = sizeof(str1) / sizeof(str1[]) - strlen(str1) - ;
    printf("length = %lu\n", length);
    strncat(str1, str2, length);
    printf("拼接后: %s\n", str1);

    // 2.字符串拷贝
    char str1[] = "lnj";
    char str2[] = "cool";
    printf("拷贝前 : str1 = %s\n", str1);
    // char * 目标, const char * 源
    // strcpy函数会将源的数据拷贝到目标中, 并且会覆盖掉目标中原有的数据
    // 目标的容积必须能够存放拷贝的数据, 如果容积不够会报错
//    strcpy(str1, str2);

    // char * 目标, const char * 源 size_t 需要拷贝几个
    // 注意: 拷贝操作是逐个替换, 拷贝了几个就替换几个
    //              str1能够存放元素的个数         - 1是给\0留出位置
    int length = sizeof(str1) / sizeof(str1[]) - ;
    strncpy(str1, str2, length);
    printf("拷贝后 : str1 = %s\n", str1);

    // 3.字符串比较
    char str1[] = "aac"; // a a
    char str2[] = "abc"; // a b

    // strcmp它会对传入的字符串进行比较, 比较完毕之后会返回一个整型的值给我们
    // 如果该值等于0,那么证明两个字符串相等
    // 如果该值小于0, 那么证明str1小于str2
    // 如果该值大于0, 那么证明str1大于str2
    // strcmp的原理: 取出字符串中的每一个字符进行逐个比较, 如果发现不相等就不会继续往下比较
    int res = strcmp(str1, str2);
    printf("res = %i\n", res);

    return ;
}

//
//  main.m
//  字符串练习
//

#include <stdio.h>
int char_contains(char str[], int length,char key);
int char_contains2(char str[],char key);

int main(int argc, const char * argv[]) {
    // 编写一个函数char_contains(char str[],char key)， 如果字符串str中包含字符key则返回数值1，否则返回数值0
    // 给你一个字符串和一个key, 要求从字符串中找出key, 如果找到就返回1没有找到就返回0
    char str[] = "xiaomage";
    char key = 'z';
    int length = sizeof(str) / sizeof(str[]);
    int res = char_contains(str, length, key);
    int res = char_contains2(str, key);
    printf("res = %i\n", res);

    return ;
}

int char_contains2(char str[],char key)
{
    /*
     xiaomage  a
     x != a  x != \0
     i != a  i != \0
     a != a

     xia  z
     x != z x != \0
     i != z i != \0
     a != z a != \0
     \0 != z \0!=\0
     */
    /*
     // 1.定义一个变量记录当前的索引
     //    int index = 0;
     // 2.遍历数组, 取出当前的字符判断是否不等于key, 并且当前出去的字符不是\0

    while (str[index] != key && str[index] != '\0') {
        index++;
    }
     */
    int index = -;
    while (str[++index] != key && str[index] != '\0');

    //          a != '\0'
    //          \0 != \0
//    int res = str[index] != '\0' ? 1 : 0;
//    return  res;
    return str[index] != '\0' ?  : ;
}

int char_contains(char str[], int length,char key)
{
    for (int i = ; i < length; i++) {
        if (str[i] == key) {
            return ;
        }
    }
    return ;

}

//
//  main.c
//  字符串数组
//
//  Created by xiaomage on 15/6/12.
//  Copyright (c) 2015年 xiaomage. All rights reserved.
//

#include <stdio.h>

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

    char name1[] = "lnj";
    char name2[] = "lmj";
    char name3[] = "xb";
    char name4[] = "lk";

    // 如果想存储一堆字符串那么可以使用字符串数组
    // 说白了字符串数组就是二维数组
    char names[][] =
    {
        "lnj",    //字符串
        "lmj",
        "xb",
        "lk",
        "xj"
    }

    char names2[][] =
    {
        {'l', 'n', 'j', '\0'},    //有\0是字符串，不是字符数组，
        {'l', 'm', 'j', '\0'}     //有\0是字符串，不是字符数组，
    }

    return ;
}