c_语法入门_day5

最新推荐文章于 2023-08-16 08:00:00 发布

pre_eminent

最新推荐文章于 2023-08-16 08:00:00 发布

阅读量837

点赞数

CC 4.0 BY-SA版权

分类专栏： # 待整理C 文章标签： c 入门

本文链接：https://blog.youkuaiyun.com/pre_eminent/article/details/25718063

待整理C 专栏收录该内容

7 篇文章

订阅专栏

H:/C语言入门/__day_5/01-字符串.c

#include <stdio.h>

int main()
{
    //char name[] = {'i', 't', 'c', 'H', 's', 't', '\0'};
    char name[] = "itcast";
    
    name[3] = 'H';
    
    /*
    int size = sizeof(name);
    
    printf("%d\n", size);
    */
    
    printf("我在%s上课\n", name);
    
    return 0;
}

// 字符串的一个初始化
void test2()
{
    // \0的ASCII码值是0
    // 都是字符串
    char name[8] = "it";
    char name2[8] = {'i', 't', '\0'};
    char name3[8] = {'i', 't', 0};
    char name4[8] = {'i', 't'};
    
    // 不算是一个字符串（只能说是一个字符数组）
    char name5[] = {'i', 't'};
}

/*
void test()
{
    // 'a' 'b' 'A'
    // "jack" == 'j' + 'a' + 'c' + 'k' + '\0'
    
    char name[10] = "jack888\n";
    
    // 把数组传入，仅仅是个警告
    printf(name);
    
    printf(name);
    
    printf(name);
    
    printf("57843578435");
}*/

H:/C语言入门/__day_5/02-字符串注意.c

#include <stdio.h>

/*
 \0的作用
 1.字符串结束的标记
 2.printf("%s", name2); 
 会从name2这个地址开始输出字符，直到遇到\0为止
 */

int main()
{
    char name[] = "itc\0ast";
    
    char name2[] = {'o', 'k'};
    
    //printf("%s\n", name2);
    
    printf("%s\n", &name2[1]);
    
    return 0;
}

H:/C语言入门/__day_5/03-strlen.c

/*
strlen函数：计算字符串长度
 1.计算的是字符数，并不是字数。一个汉字算作3个字符
 2.计算的字符不包括\0
 3.从某个地址开始数字符的个数，直到遇到\0为止
*/

// strlen函数声明在string.h文件中
#include <string.h>
#include <stdio.h>

int main()
{
    //int size = strlen("哈haha");

    //printf("%d\n", size);
    /*
    char name[] = "itcast";
    char name2[] = {'0', '\0', '6'};
    
    int size = strlen(name2);
    
    printf("%d\n", size);
    */
    
    char name[] = "itcast";
    
    //printf("%s\n", name);
    
    printf("%c\n", name[3]);
    
    
    return 0;
}

H:/C语言入门/__day_5/04-字符串练习.c

/*
编写一个函数char_contains(char str[],char c)，
 如果字符串str中包含字符c则返回数值1，否则返回数值0
*/

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

// 可读性 -> 性能 -> 精简（重构）

int char_contains(char str[], char c);

int main()
{
    //int result = char_contains("itc8ast", '8');
    
    char name[] = "itcast";
    
    int result = char_contains(name, 'o');
    
    printf("%d\n", result);
    return 0;
}

// "itc"  '7'
int char_contains(char str[], char c)
{
    int i = -1;
    
    /*
     i  3
     str[++i] 'c'
     c  '7'
     */
    
    // 1.遍历整个字符串
    while ( str[++i] != c && str[i] != '\0' ) ;
    
    //return str[i] == '\0' ? 0 : 1;
    return str[i] != '\0';
}

/*
int char_contains(char str[], char c)
{
    int i = -1;
    
    // 1.遍历整个字符串
    while ( str[++i] )
    {
        // 如果发现某个字符等于参数c，直接返回1，退出函数
        if (str[i] == c)
        {
            return 1;
        }
    }
    
    // 2.说明str里面不包含字符c
    return 0;
}*/

/*
int char_contains(char str[], char c)
{
    int i = 0;
    
    // 1.遍历整个字符串
    while ( str[i] != '\0' )
    {
        // 如果发现某个字符等于参数c，直接返回1，退出函数
        if (str[i] == c)
        {
            return 1;
        }
        
        i++;
    }
    
    // 2.说明str里面不包含字符c
    return 0;
}*/

/*
int char_contains(char str[], char c)
{
    // 1.遍历整个字符串
    for (int i = 0; i<strlen(str); i++)
    {
        // 如果发现某个字符等于参数c，直接返回1，退出函数
        if ( str[i] == c )
        {
            return 1;
        }
    }
    
    // 2.说明str里面不包含字符c
    return 0;
}*/

H:/C语言入门/__day_5/05-字符串数组.c

#include <stdio.h>
int main()
{
    char name[] = "jack";
    
    char name1[] = "rose";
    
    char name2[] = "jim";
    
    char name3[] = "jake";
    
    char names[2][10]= {"jack", "rose"};
    
    //printf("%s\n", names[0]);
    
    //printf("%c\n", names[0][3]);
    
    char names2[2][10] =
    {
        {'j', 'a', 'c', 'k', '\0'},
        {'r', 'o', 's', 't', '\0'}
    };
    
    
    return 0;
}

H:/C语言入门/__day_5/06-指针.c

#include <stdio.h>

void change(int);

int main()
{
    /*
    int a = 90;
    
    change(&a);
    
    printf("a=%d\n", a);
    */
    
    // 变量类型  变量名;
    // 格式：变量类型 *变量名;
    // 定义了一个指针变量p
    // 指针变量只能存储地址
    // 指针就一个作用：能够根据一个地址值，访问对应的存储空间
    // 指针变量p前面的int：指针变量p只能指向int类型的数据
    int *p;
    
    int a = 90;
    
    // 指针变量p指向了变量a
    p = &a;
    
    *p = 10;

    a = 20;
    
    printf("%d\n", *p);
    
    //printf("%d\n", a);
    
    return 0;
}

void change(int n)
{
    n = 10;
}

H:/C语言入门/__day_5/07-指针练习.c

#include <stdio.h>

void change(int *n);

int main()
{
    int a = 90;
    
    change(&a);
    
    printf("%d\n", a);
    
    return 0;
}

void change(int *n)
{
    *n = 10;
}

H:/C语言入门/__day_5/08-指针的使用注意.c

#include <stdio.h>

int main()
{
    /* 不建议的写法， int *p只能指向int类型的数据
    int *p;
    double d = 10.0;
    p = &d;*/
    
    /* 指针变量只能存储地址
    int *p;
    p = 200;
    */
    
    /* 指针变量未经过初始化，不要拿来间接访问其他存储空间
    int *p;
    printf("%d\n", *p);
    */
    
    int a = 10;
    /*
    int a;
    a = 10;
    */
    
    /*
    int *p;
    p = &a;
    */
    // 定义变量时的*仅仅是一个象征，没有其他特殊含义
    int *p = &a;
    
    // 不正确的写法
    // *p = &a;
    p = &a;
    
    // 这个时候的*的作用：访问指向变量p指向的存储空间
    *p = 20;
    
    
    char c = 'A';
    
    char *cp = &c;
    
    *cp = 'D';
    
    printf("%c\n", c);
    
    return 0;
}

H:/C语言入门/__day_5/09-指向指针的指针.c

#include <stdio.h>
int main()
{
    int a = 10;
    
    int *p = &a;
    
    int **pp = &p;
    
    // a = 20;
    
    // *p = 20;
    
    /*
    (*pp) == p
    
    *(*pp) == *p = a
    
    **pp == *p = a
    */
    **pp = 20;
    
    printf("%d\n", a);
    
    //int ***ppp = &pp;
    
    /*
    char a2 = 'A';
    char *p2 = &a2;
    */
    
    return 0;
}

H:/C语言入门/__day_5/10-指针复习.c

#include <stdio.h>
int main()
{
    double d = 10.5;
    double d2 = 10.5;
    
    double *p;
    p = &d;
    
    *p = 10.9;
    
    p = &d2;
    
    *p = 10.9;
    
    printf("d=%f, d2=%f\n", d, d2);
    
    
    // 清空指针
    p = 0;
    // p = NULL;
    
    // 清空指针后，不能再间接访问其他存储空间
    // *p = 100.7;
    
    return 0;
}

H:/C语言入门/__day_5/11-指针练习1.c

#include <stdio.h>
void swap(int *v1, int *v2);

int main()
{
    /*
    int a = 10;
    int b = 11;
    
    swap(&a, &b);
    */
    
    
    int a2 = 90;
    int b2 = 89;
    
    swap(&a2, &b2);
    
    printf("a2=%d, b2=%d\n", a2, b2);
    return 0;
}

/* 不能交换外面实参的值，仅仅是交换了内部指针的指向
void swap(int *v1, int *v2)
{
    int *temp;
    temp = v1;
    v1 = v2;
    v2 = temp;
}*/

// 完成两个整型变量值的互换
void swap(int *v1, int *v2)
{
    int temp = *v1;
    *v1 = *v2;
    *v2 = temp;
}

/* 交换的只是内部v1、v2的值
void swap(int v1, int v2)
{
    int temp = v1;
    v1 = v2;
    v2 = temp;
}*/

H:/C语言入门/__day_5/12-指针练习2.c

#include <stdio.h>
int sumAndMinus(int n1, int n2, int *n3);

int main()
{
    int a = 10;
    int b = 7;
    
    // 存储和
    int he;
    // 存储差
    int cha;
    c
    he = sumAndMinus(a, b, &cha);
    
    printf("和是%d, 差是%d\n", he, cha);
    
    return 0;
}

// 返回值是
int sumAndMinus(int n1, int n2, int *n3)
{
    *n3 = n1 - n2;
    
    return n1 + n2;
}

H:/C语言入门/__day_5/13-指针疑问.c

/*
 %d int
 %f float\double
 %ld long
 %lld long long
 %c char
 %s 字符串
 %zd  unsigned long
 */

#include <stdio.h>

/*
 0000 0001
 0000 0010
 0000 0000
 0000 0000
 
 0000 0000 0000 0000 0000 0010 0000 0001
 */

int main()
{
    // 0000 0000 0000 0000 0000 0000 0000 0010
    int i = 2;
    // 0000 0001
    char c = 1;
    
    char *p;
    p = &c;
    
    //*p = 10;
    
    printf("c的值是%d\n", *p);
    
    return 0;
}

void test()
{
    char c; // 1
    int a; // 4
    long b; // 8
    
    // 任何指针都占用8个字节的存储空间
    char *cp;
    int *ap;
    long *bp;
    
    printf("cp=%zd, ap=%zd, bp=%zd\n",
           sizeof(cp),
           sizeof(ap),
           sizeof(bp));
}

H:/C语言入门/__day_5/14-指针和数组.c

#include <stdio.h>

/*
 1.数组元素的访问方式
 int ages[5];
 int *p;
 p = ages;
 1> 数组名[下标]  ages[i]
 2> 指针变量名[下标] p[i]
 3> *(p + i)
 
 2.指针变量+1，地址值究竟加多少，取决于指针的类型
  int *   4
  char *  1
  double * 8
 */
void change(int array[]);

int main()
{
    // 20个字节
    int ages[5] = {10, 11, 19, 78, 67};
    
    change(ages);
    
    return 0;
}

// 利用一个指针来接收一个数组，指针变量array指向了数组的首元素
void change(int *array)
{
    printf("%d\n", array[2]);
    //printf("%d\n", *(array+2));
}

/*
void change(int array[])
{
    int s = sizeof(array);
    
    printf("%d\n", s);
}*/

void test()
{
    double d = 10.8;
    double *dp;
    dp = &d;
    
    printf("dp = %p\n", dp);
    printf("dp + 1 = %p\n", dp + 1);
    
    int ages[5] = {10, 9, 8, 67, 56};
    
    int *p;
    // 指针变量p指向了数组的首元素
    p = &ages[0];
    // 数组名就是数组的地址，也是数组首元素的地址
    //p = ages;
    
    /*
     p ---> &ages[0]
     p + 1 ---> &ages[1]
     p + 2 ---> &ages[2]
     p + i ---> &ages[i]
     */
    
    //printf("%d\n",  *(p+2));
    
    printf("%d\n",  p[2]);
    
    /*
     for (int i = 0; i<5; i++) {
     printf("ages[%d] = %d\n", i, *(p+i));
     }*/
    
    
    //    printf("%p\n", p);
    //    printf("%p\n", p + 1);
    //    printf("%p\n", p + 2);
}

H:/C语言入门/__day_5/15-指针和字符串.c

#include <stdio.h>

/*
 1.常量区
 存放一些常量字符串
 
 2.堆
 对象
 
 3.栈
 存放局部变量
 
 掌握：
 定义字符串的2种方式
 1> 利用数组
 char name[] = "itcast";
  * 特点：字符串里面的字符是可以修改的
  * 使用场合：字符串的内容需要经常修改
 
 2> 利用指针
  char *name = "itcast";
  * 特点：字符串其实是一个常量字符串，里面的字符是不能修改
  * 使用场合：字符串的内容不需要修改，而且这个字符串经常使用
 */

int main()
{
    char name[20];
    
    printf("请输入姓名：\n");
    
    scanf("%s", name);
    
    // 'j' 'a' 'c' 'k' '\0'
    
    //printf("%c\n", name[3]);
    
    //printf("刚才输入的字符串是：%s\n", name);
    
    return 0;
}

// 定义字符串数组
void test2()
{
    char *name = "jack";
    
    //int ages[5];
    
    // 指针数组（字符串数组）
    char *names[5] = {"jack", "rose", "jake"};
    
    // 二维字符数组（字符串数组）
    char names2[2][10] = {"jack", "rose"};
}

// 定义字符串
void test()
{
    // 字符串变量
    char name[] = "it";
    name[0] = 'T';
    
    //printf("%s\n", name);
    
    
    // "it" == 'i' + 't' + '\0'
    // 指针变量name2指向了字符串的首字符
    
    // 字符串常量
    char *name2 = "it";
    
    char *name3 = "it";
    
    //*name2 = 'T';
    
    //printf("%c\n", *name2);
    
    printf("%p\n%p\n", name2, name3);
    
    //printf("%s\n", name2);
}

H:/C语言入门/__day_5/16-指针和字符串练习.c

#include <stdio.h>
/*
 (不包括\0)
 编写一个int string_len(char *s)，返回字符串s的字符长度
 
 */
int string_len(char *s);

int main()
{
    //char *name = "itcast";
    
   // 男 \u434\u4343\u434
    
    int size = string_len("tre777");
    
    printf("%d\n", size);
    return 0;
}

int string_len(char *s)
{
    // 1.定义一个新的指针变量指向首字符
    char *p = s;
    
    /*
    while ( *s != '\0' )
    {
        s++;
    }*/
    
    while ( *s++ ) ; 
    
    return s - p - 1;
}

/*
int string_len(char *s)
{
    // 记录字符的个数
    int count = 0;
    
    // 如果指针当前指向的字符不是'\0'
    // 首先*s取出指向的字符
    // 然后s++
    while ( *s++ )
    {
        // 个数+1
        count++;
        
        // 让指针指向下一个字符
        //s = s + 1;
        //s++;
    }
    
    return count;
}
*/

/*
int string_len(char *s)
{
    // 记录字符的个数
    int count = 0;
    
    // 如果指针当前指向的字符不是'\0'
    while ( *s != '\0')
    {
        // 个数+1
        count++;
        
        // 让指针指向下一个字符
        //s = s + 1;
        s++;
    }
    
    return count;
}*/

H:/C语言入门/__day_5/17-指针总结.c

一、指针变量的定义
1. 格式：变量类型 *指针变量名;
2. 举例：int *p;   char *p2;
3. 注意：定义变量时的*仅仅是指针变量的象征

二、利用指针变量简单修改其他变量的值
1.指向某个变量
int a;

int *p;
p = &a;
或者
int *p = &a;

2.修改所指向变量的值
*p = 10;

3.在函数内部修改外面变量的值
int a = 10;
change(&a);

void change(int *n)
{
    *n = 20;
}

三、指针与数组
1.将数组当做函数参数传入时，会自动转为指针

四、指针与字符串
1.定义字符串的2种方式
1> 利用数组
char name[] = "itcast";
* 特点：字符串里面的字符是可以修改的
* 使用场合：字符串的内容需要经常修改

2> 利用指针
char *name = "itcast";
* 特点：字符串其实是一个常量字符串，里面的字符是不能修改
* 使用场合：字符串的内容不需要修改，而且这个字符串经常使用

2.定义字符串数组
1> 利用二维字符数组
char names[2][10] = {"jack", "rose"};

2> 利用指针数组
char *names[2] = {"jack", "rose"};