C语言练习 -- 3

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

int main()
{
    int a = 0;
    //~按（2进制）位取反
    //00000000000000000000000000000000
    //11111111111111111111111111111111 - 补码 
    //11111111111111111111111111111110 - 反码
    //10000000000000000000000000000001 - 原码
    //-1
    printf("%d\n", ~a);
    return 0;
}

int main()
{
    int a = 11;
    a = a | (1 << 2);
    printf("%d\n", a);//15
    //00000000000000000000000000001011
    //00000000000000000000000000000100
    // 1<<2
    //00000000000000000000000000001111
    a = a & (~(1 << 2));
    printf("%d\n", a);//11
    return 0;
}

int main()
{
    int a = 10;
    //printf("%d\n", ++a);//前置++，先++，后使用
    printf("%d\n", a++);//后置++，先使用，再++
    return 0;
}


int main()
{
    int a = (int)3.14;
    return 0;
}

int main()
{
    int a = 3;
    int b = 5;
    int c = a && b;
    printf("%d\n", c);
    return 0;
}

&& - 从前往后，判断为0，后面就不算了
|| - 从前往后，判断为1，后面就不算了


int main()
{
    int a = 0;
    int b = 0;
    if (a > 5)
    {
        b = 3;
    }
    else
        b = -3;
    //用三目操作符
    b = (a > 5? 3 : -3);
    return 0;
}


int main()
{
    int a[10] = { 0 };
    a[4] = 10;
    1 + 2;
    return 0;
}

int get_max(int x, int y)
{
    return x > y ? x : y;
}
int main()
{
    int a = 10;
    int b = 20;
    //调用函数的时候的（）就是函数调用操作符
    int max = get_max(a,b);
    printf("max = %d\n", max);
    return 0;
}

学生
int float

创建了一个结构体类型 - struct Stu
struct Stu
{
    //成员变量
    char name[20];
    int age;
    char id[20];
};
int main()
{
    int a = 10;
    //使用struct Stu这个类型创建了一个学生对象s1，并初始化
    struct Stu s1 = {"张三",20,"B18040203011"};
    struct Stu* ps = &s1;

    printf("%s\n", ps->name);
    printf("%d\n", ps->age);
    //结构体指针->成员名

    //printf("%s\n", (*ps).name );
    //printf("%d\n", (*ps).age);
    
    //printf("%s\n", s1.name);
    //printf("%d\n", s1.age);
    //printf("%s\n", s1.id);
    //结构体变量.成员名
    return 0;
}


int main()
{
    char a = 3;
    //00000000000000000000000000000011
    //00000011 - a
    //
    char b = 127;
    //00000000000000000000000001111111
    //01111111 - b
    //a和b如何相加
    //00000011
    //01111111
    char c = a + b;
    printf("%d\n", c);
    return 0;
}


int main()
{
    int a = 10;
    int b = 20;
    int c = b + a + 3;
    printf("%d\n", c);
    return 0;
}


int main()
{
    int a = 0;
    int c = 1;
    a = c + --c;//不同编译器结果不同，不建议这么写
    printf("%d\n", c);
    return 0;
}


int main()
{
    int a = 0x11223344;


    //int* pa = &a;
    //*pa = 0;

    char* pc = &a;
    *pc = 0;
    //指针类型决定了指针进行解引用操作的时候，能够访问空间的大小
    // int*p; *p能够访问4个字节
    // char*p； *p能够访问1个字节
    // double*p； *p能够访问8个字节
    
    //printf("%p\n", pa);
    //printf("%p\n", pc);
}


int main()
{
    int arr[10] = { 0 };
    char* p = arr;//数组名 - 首元素的地址
    int i = 0;
    for (i = 0; i < 10; i++)
    {
        *(p + i) = 1;
    }
    return 0;
}


野指针
int main()
{
    //int a;//局部变量不初始化，默认是随机值
    int* p;//局部指针变量，不初始化，默认随机值
    *p = 20;
    return 0;
}


int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    int i = 0;
    for (i = 0; i < 12; i++)
    {
        p++;//指针会越界
    }
    return 0;
}

野指针（空间被释放）
test()
{
    int a = 10;
    return &a;
}
int main()
{
    int* p = test();
    *p = 20;
    return 0;
}


int main()
{
    //未初始化的指针变量
    int* p;//局部变量不初始化，里面默认放的是一个随机值
    *p = 20;
    return 0;
}


int main()
{
    //int a = 10;
    //int* pa = &a;//初始化
    //int* p = NULL;//NULL - (int*)0 - 空指针 - 用来初始化指针，即指针赋值

    int a = 10;
    int* pa = &a;
    *pa = 20;
    pa = NULL;
    *pa = 10;//error

    if (pa != NULL)
    {

    }
}



int main()
{
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    int i = 0;
    int sz = sizeof(arr) / sizeof(arr[0]);
    int* p = &arr[9];
    //for (i = 0; i < sz; i++)
    //{
    //    printf("%d ", *p);
    //    //p = p + 1;
    //    p++;
    //}

    for (i = 0; i < 5; i++)
    {
        printf("%d ", *p);
        //p = p + 1;
        p-=2;
    }
    return 0;
}



int main()
{
    char ch[5] = { 0 };
    int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
    printf("%d\n", &arr[9] - &arr[0]);
    printf("%d\n", &arr[9] - &ch[0]);//err
    return 0;
}


int my_strlen(char* str)
{
    char* start = str;
    char* end = str;
    while (*end != '\0')
    {
        end++;
    }
    return end - start;
}
int main()
{
    //strlen - 求字符串长度
    //递归 - 模拟实现了 strlen - 计数器的方式
    char arr[] = "bit";
    int len = my_strlen(arr);
    printf("%d\n", len);
    return 0;
}


int main()
{
    int arr[10] = { 0 };
    printf("%p\n", arr);//地址 - 首元素地址
    printf("%p\n", arr+1);

    printf("%p\n", &arr[0]);
    printf("%p\n", &arr[0]+1);

    printf("%p\n", &arr);//
    printf("%p\n", &arr+1);

    //1.&arr - &数组名 - 数组名不是首元素的地址 - 数组名表示整个数组 - &数组名 取出的是整个数组的地址
    //2.sizeof(arr) - sizeof(数组名) - 数组名表示的是整个数组 - sizeof(数组名)计算的是整个数组的大小

    return 0;
}


int main()
{
    int arr[10] = { 0 };
    int* p = arr;
    int i = 0;

    for (i = 0; i < 10; i++)
    {
        *(p + i) = i;
    }
    for (i = 0; i < 10; i++)
    {
        printf("%d ", arr[i]);
        //printf("%d ", *(p + i));
    }
    //for (i = 0; i < 10; i++)
    //{
    //    printf("%p ============== %p\n", p + i,&arr[i]);
    //}
    return 0;
}


int main()
{
    int a = 10;
    int* pa = &a;
    int** ppa = &pa;//ppa就是二级指针
    //int*** pppa = &ppa;
    **ppa = 20;
    printf("%d\n", **ppa);
    printf("%d\n", a);
    return 0;
}


指针数组 - 数组 - 存放指针的数组
数组指针 - 指针 - 

int main()
{
    int a = 10;
    int b = 20;
    int c = 30;
    int* pa = &a;
    int* pb = &b;
    int* pc = &c;
    整型数组 - 存放整型
    字符数组 - 存放字符
    指针数组 - 存放指针
    int arr[10];
    
    int* arr2[3] = {&a,&b,&c};//指针数组
    int i = 0;
    for (i = 0; i < 3; i++)
    {
        printf("%d\n", *(arr2[i]));
    }
    return 0;
}