函数，数组，原码反码补码，~ 按位取反，-- ++ 前置后置，下标，#define 定义常量宏，指针学习笔记

最新推荐文章于 2024-06-14 10:22:04 发布

考研人君君

最新推荐文章于 2024-06-14 10:22:04 发布

阅读量149

点赞数

文章标签： c语言 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_75154705/article/details/128863700

版权

函数

void MAX(int a, int b) //定义函数

数组

一组相同类型数据的集合

int arr[10] = {0,1,2,3,4}; //定义一个整型的数组占10*4个字节

原码、反码、补码

只要是整数，内存中都是二进制的补码

原码、反码、补码

负数再内存中存储的是二进制的补码有符号数最高位0表示正数 1表示负数

使用的，打印的是这个数的原码

原码符号位不变，其他位按位取反得到反码，反码加一得到补码

反过来补码-1=反码反码按位取反=原码

~ 按位取反

int a = 0; //4个字节 0000 0000 0000 0000 0000 0000 0000 0000

int b = ~a; // 1111 1111 1111 1111 1111 1111 1111 1111

-- ++ 前置后置

前置++先++，后使用

三目操作符

条件操作符 exp1? exp2: exp3 exp是表达式的意思

?前面为真执行第二个，若前面为假执行第三个

typedef 类型定义类型重定义

int a = (int)3.14; //强制类型转换double->int

static

修饰局部变量生命周期变长逗号表达式分隔

修饰全局变量作用域改变让静态全局变量只能在自己所在源文件内部使用

修饰函数作用域只能在自己所在源文件内部使用（改变函数连接属性一般函数都有外部连接）

下标

[] () -> .

()函数调用操作符

[]下表标引用操作符

常见关键字

定义不能冲突不能自己创建 define 是一种指令不是关键字

F10调试 F11进入函数要开启监视窗口

#define 定义常量宏

#define MAX 1000 定义标识符常量

#define 可以定义宏一带参数

宏的定义方式

#define MAX(X,Y) (X>Y?X:Y) //不用写类型简洁

比较函数的定义方式

int Max(int x, int y)

{

if (x > y)

return x;

else

return y;

}

指针

内存地址编号内存中一个个小单元（可以看成内存小格子）地址->空间

如何产生地址，32位 64位 32根地址线正电负电2^32个字节编号bit 4,94,679,296

申请内存

&取地址符号看它的地址

int* p = &a; //取地址 int*是类型 p是指针变量 p存的是a的地址

*p = 20;//*p解引用操作符，改变变量的值 *p就相当于20

32位系统下32bit 4个字节

#define _CRT_SECURE_NO_WARNINGS

//练习笔记
//#include <stdio.h>
//
//int main()
//{
//    int a, b, c;
//    scanf("%d%d", &a, &b);
//    if (a > b)
//    {
//        c = a;
//        printf("%d", c);
//    }
//    else
//    {
//        c = b;
//        printf("%d\n", b);
//    }
//    return 0;
//}

//#include <stdio.h>
//
//void  MAX(int a, int b)                //定义函数
//{
//    int c;
//    if (a > b)
//    {
//        c = a;
//        printf("%d\n", c);            //或者return c；返回后再操作
//    }
//    else
//    {
//        c = b;
//        printf("%d\n", b);
//    }
//}
//int main()
//{
//    int num1 = 30;
//    int num2 = 50;
//    MAX(num1, num2);                //传参num1 num1
//    return 0;
//}

//*******************************************************************//
//数组 一组相同类型数据的集合

//#include <stdio.h>
//int main()
//{
//    int arr[10] = {0,1,2,3,4};        //定义一个整型的数组占10*4个字节
//    int arr1[] = { 0,1,2,3,4 };
//    printf("sizeof(arr)=%d\n", sizeof(arr));
//    printf("sizeof(arr2)=%d\n", sizeof(arr1));        //计算数组的大小，单位是字节 20
//    return 0;
//}
//
//#include <stdio.h>
//
//int main()
//{
//    //~ 按位取反
//    int a = 0;            //4个字节 0000 0000 0000 0000  0000 0000 0000 0000 
//    int b = ~a;            //       1111 1111 1111 1111 1111 1111 1111 1111
//    printf("%d\n", b);
// //只要是整数，内存中都是二进制的补码
//    //原码、反码、补码 
//    //负数再内存中存储的是二进制的补码 有符号数最高位0表示正数 1表示负数
//    //使用的，打印的是这个数的原码
//    //原码符号位不变，其他位按位取反得到反码，反码加一得到补码
//    //反过来补码-1=反码 反码按位取反=原码
// -2
// 1000 0000 0000 0000 0000 0000 0000 0000 0010
//    return 0;
//}

//#include <stdio.h>
//
-- ++ 前置 后置
//
//int main()
//{
//    int a = 10;
//    int b = a++;    //后置++先使用，后++
//    printf("a=%d b=%d\n", a, b); //a=11,b=10
//    int c = 10;
//    int d = ++c;    //前置++先++，后使用
//    printf("c=%d d=%d\n", c, d);        //11 11
//    //后置-- ++同理
//    int num1 = 10;
//    int num2 = num1--;
//    printf("num1=%d\n num2=%d\n", num1, num2);
//    return 0;
//}
//
//#include <stdio.h>
强制类型转换
//int main()
//{
//    int a = (int)3.14;            //强制类型转换double->int
//    return 0;
//}
//
//关系操作符>= <= ==

逻辑操作符  真-非零 假-0
逻辑与 &&
逻辑或 ||
//#include <stdio.h>
//
//int main()
//{
//    int a = 3;
//    int b = 5;
//    int c = a && b;                //左右为真，所以为真 并且
//    printf("%d\n", c);            //1
//    int d = a || b;                //只要一个为真就为真，张三和李四搬凳子
//    printf("%d\n", d);            //1
//    return 0;
//}

//#include <stdio.h>
//
条件操作符 exp1?  exp2: exp3  exp是表达式的意思 三目操作符
//
//int main()
//{
//    int a = 10;
//    int b = 20;
//    int max = 0;
//    max = (a > b ? a : b);  //?前面为真执行第二个，若前面为假执行第三个
//    return 0;
//}

//逗号表达式 分隔
//下标  []    ()   ->    .
//#include <stdio.h>
//
//int Add(int num1, int num2)
//{
//    int z = 0;
//    z = num1 + num2;
//    return 0;
//}
//
//int main()
//{
//    int arr[10] = { 0 };        //[]下表引用操作符
//    int a = 10;
//    int b = 20;
//    int sum = Add(a, b);        //()函数调用操作符
//    return 0;
//}
1111 1111 1111 1111 1111 1111 1111 1111
1000 0000 0000 0000 0000 0000 0000 0000 0
1*2^32-1
-1 --整型-32
1 --整型-32
 [1]符号位[][][] [][][][] [][][][] [][][][] [][][][] [][][][] [][][][] [][][][] 
有符号


常见关键字  定义不能冲突 不能自己创建 define 是一种指令不是关键字

//#include <stdio.h>
//
//int main()
//{
//    //auto 自动创建自动销毁，一般都有所以不写省略
//    auto int a = 10;
//    //break case case const continue defaut do double else enum extern float for 
//    //if int long goto registe 建议定义成寄存器变量 计算机存储（寄存器最快 高速缓存 内存 硬盘）访问速度越前越快 (CPU 中央处理器)
//    //return short unsigned signed sizeof static struct switch typedf union void volatile while 
//    return 0;
//}

//#include <stdio.h>
//
typedef 类型定义 类型重定义
//
//int main()
//{
//    typedef unsigned int u_int;                //u_int 与unsigned int 相同
//    unsigned int num = 20;
//    u_int num2 = 20;
//    return 0;
//}

//#include <stdio.h>
//
static 修饰局部变量 生命周期变长 
//
//void test()
//{
//    //static int a = 1;                        //加static 静态局部变量，不销毁
//    int a = 1;
//    a++;
//    printf("a=%d\n", a);                    //5个a=2 函数出去后生命周期结束，销毁
//}
//
//int main()
//{
//    int i = 0;
//    while (i < 5)
//    {
//        test();        //F10调试 F11进入函数 要开启监视窗口
//        i++;
//    }
//    return 0;
//}

//#include <stdio.h>
//
static 修饰全局变量 作用域改变 让静态全局变量只能在自己所在源文件内部使用
//
//int main()
//{
//    extern int g_val;        //extern 声明外部符号 如果外部这个全局变量 加 static 则失败
//    printf("%d\n", g_val);
//    return 0;
//}

//#include <stdio.h>
//
static修饰函数 作用域 只能在自己所在源文件内部使用（改变函数连接属性 一般函数都有外部连接）

int main()
//
//extern int Add(int, int);        //声明外部函数  分号
//
//int main()
//{
//    int a = 10;
//    int b = 20;
//    int sum = Add(a,b);
//    printf("sum=%d\n", sum);
//    return 0;
//}

//#include <stdio.h>
//
#define 定义常量 宏
#define MAX 1000 定义标识符常量 
#define 可以定义宏一带参数
//
函数的定义方式
//int Max(int x, int y)
//{
//    if (x > y)
//        return x;
//    else
//        return y;
//}
宏的定义方式
//#define MAX(X,Y) (X>Y?X:Y)            //不用写类型 简洁
//int main()
//{
//    int a = 10;
//    int b = 20;
//    int max = Max(a,b);
//    printf("max=%d\n", max);
//    //宏的方式
//    max = MAX(a,b);                //max=(a>b?:b)  这是编译器完成的
//    printf("max=%d\n", max);
//    return 0;
//}


指针
内存 地址编号 内存中一个个小单元（可以看成内存小格子）地址->空间
如何产生地址，32位 64位 32根地址线 正电 负电2^32个字节编号bit 4,94,679,296
申请内存 
&取地址符号 看它的地址
//#include <stdio.h>
//
//int main()
//{
//    int a = 0;
//    printf("%p\n", &a);        //十六进制
//    int* p = &a;                    //取地址  int*是类型 p是指针变量 p存的是a的地址
//    //有一种变量是用来存放地址的指针变量
//    printf("%p\n", p);
//    *p = 20;//*p解引用操作符，改变变量的值 *p就相当于20
//    printf("a=%d", a);
//    return 0;
//}

#include <stdio.h>

int main()
{
    char ch = 'w';
    char* pc = &ch;                            //char型
    *pc = 'a';
    printf("%c\n", ch);
    printf("%d\n", sizeof(pc));                //Debug->配置管理器->新建X64
    return 0;
}
//32位系统下32bit 4个字节
//已知地址取值写法很危险；