001-C

 

2:第一个c语言程序：

编译命令

cc -c 文件名.c

编译过后 生成一个.o的文件 

把目标.o文件与系统自带的函数库合并，生成一个可执行文件

cc文件名.o 

生成一个.out文件 unix可执行文件 

双击 使用终端打开 或者

./文件名.out  使用命令打开当前文件 

 

3：第二个 

mkdir 002 新建一个002的文件夹

touch xx.c 新建一个.c文件

open xx.c打开xx文件

cc 文件名.o -o test 更改默认的a.out为test.out 

4：c 关键字

32个关键字 

特征：全部都是小写

     都为紫褐色

     

标示符

自定义的符号

命名

英文字母大小写 数字 下划线组成

 

     

 

5:  变量

整型 int 占4个字节

字符 char 占1个字节

printf(“%d”，num’)  %d 占位符 整数 表示最后放的变量必须是整型 或者%i

%f 表示 float 浮点类型的数据

%.2f 保留两位小数 %.4保留四位小数

%c char  字符类型 

6:  变量的作用域 

代码执行顺序必须是从上到下 从定义变量开始一直到函数结束

执行变量按照就近原则

用大括号括起来就代表是一个函数块

  

7：变量的内存分析

1，字节和地址

   1GB=1024MB=2048KB=2048*1024B

2，地址分配

   从大到小

   输出地址用 %p   &变量

 

8： scanf函数

printf输出内容

scanf输入内容 

scanf(“%d”,&num);

 

scanf(“%d,%d”,&num1,&num2);

输入是必须按照逗号分开

如果是按照空格分隔，则需要回车输入

不能输入\n回车符 

 

9： 运算符

+-*/加减乘除

取余% 两个数相除的余数 取余正负性只跟%左边数值正负有关

1/2 =0 

a++  先作赋值运算后+1

++a  先加完再作赋值运算

 

 

10： sizeof函数

计算对象的字节数 int 4 char 1 double 8

int size = sizeof(10);

int size = sizeof 10;

 

11： 关系运算符

1,真假 任何非0值都是真 0为假 c语言没有没有bool类型

2，比较运算 > < >= <= == != 大于 小于 大于等于 小于等于 等于 不等于

int result =a>b; 条件成立 返回值为1 否则返回0

3，运算符优先级 

int a = 2==3>1;从左到右  == ！= 优先级相等 <,<=,>,>=优先级相等 且比==！=大

08

 

12：  返回值

void  int double float char 

13：  函数

1，函数不能嵌套声明

2，方法名称不能相同

3，函数必须写到main函数前面 c语言编译器是从上到下执行 可以事先声明函数 void xxx();

4，纯文本赋值  #include “xxx.txt” 相对路径 自己写的文件用双引号，系统自带的用尖括号

14：char类型

一个字节

大写A从65开始

小写a从97开始

一个汉字 三个字节 或者两个字节 看编译器

 

 

15：数组  构造类型

只能存放一种类型的数据

int ages[50] ={11,11,11,```};

int ages[5] = {[3]=10,[4]=11 };

int ages[] = {1,2,3,4};

int ages[‘a’] = {1,2,3,4};

 

 

数组名作为函数参数 所传递的是地址传递

数组作为参数传递时，会当做指针变量使用 再64位编译器环境下占8个字节

所以想要再函数中知道数组的长度 必须另传递一个数组长度

二维数组

int ages[3][5]={

{1,2,3,4,5},

{},

{},

};

 

16：指针

char name[] =“it”;

char *name2 =“it”;//指针变量name2指向字符串的首字母

 

内存分三块：1，常量区 存放常量    2，堆 存放对象，3，栈 存放变量

数组是分配再栈中 为 变量 可随意更改

指针 存放再常量区 不可更改

 

17:返回指针函数 

char *test(){}

指向函数指针

（*p）固定写法 代表指针变量p是指向函数

void 指针变量p指向的函数没有返回值

() 函数没有形参

void (*p)();

p = 函数地址;//函数名就代表函数地址 传入函数名即可

调用：p=test;

1，p();

2,(*p)();

3,test();

 

1，进制

    int num = 0b1100;//二进制加0b num =12;

    int num = 014; //八进制  加0 代表八进制

    int num = 0xc; //十六进制 加0x 代表16进制

    输出 %d、%i十进制%o 八进制%x十六进制%u十进制%c一个字符

    %s一个或多个字符%f小数形式双精度默认6位小数%e标准指数双精度小数6位

    %p输出地址

    最高位是0代表正数 最高位是1代表负数,  原码，反码，补码。

    二进制转十进制

    0b1110= 0*2的0次方+1*2的1次方+·······；

    十进制转二进制

    67 = 64+2+1=2的6次方+2的1次方+2 的0次方；

          = 0b1000000+0b10+0b1=0b1000011

    n位二进制的取值范围

    2位二进制的取值范围：0-3 0-2的2次方-1

    3位二进制的取值范围：0-7 0-2的3次方-1

    n位二进制的取值范围：0-2的n次方-1

2. int short long signed unsigned

    long int a = 32323232424343434434l;

    long可以把int从4个字节扩充到八个字节 只是为了修饰int 

    long int 相等于long int 输出 用%ld 

    long long int 相等于long int 输出 %lld  跟编译器有关

    short 2个字节 输出 用%d

    signed int a = 10;

    unsigned int b = 10;输出 %u

    signed 有符号 包含正数，0，负数 int默认有符号 signed一般无用

    unsigned 无符号 包含 0，正数 代表最高位不是符号位 

    所以最大范围从开始的2的31次方-1 变成 2的32次方-1

    

3 位运算

    1，&  按位与 二进制中，与1相&保持1 与0相与就为0

        9&5；

        1001

        0101

    ----------

        0001

        9&5 结果为1

    2. | 按位或 只要对应的两个二进制位有一个为1时结果就为1否则为0

        9|5；

        1001

        0101

    --------------

        1101

        9|5 结果为13

    

    3,^ 按位异或  对应的二进制位相异 不想用是 结果为1 否则为0

        9^5 =1001^0101=1100=12

        1,任何数值跟0异或 ，结果还是原来的数值

     4,~按位取反  取二进制相反的数值

    5，<<左移 把正数a的各二进制位向左移动n位

        舍弃最高位 末尾补0

        9<<1  == 9*2的1次方==18

        9<<2 == 9*2的2次方==36

        9<<n == 9*2的n次方 ==

        9*2的10次方 == 9<<3

        可能导致正负性不定

    6,>>右移 

        保持符号位不变 往右移

        跟左移相反 为相除

    7,

        交换变量

        a = a^b; b = a^b;a=a^b;

        判断奇偶性

        二进制最后一位为1 是奇数 0 是偶数

        所以  a&1==1 奇数

                a&1 ==0 偶数

        输出二进制

        int temp = 31;//int temp =( sizeof(number)<<3)-1;==sizeof(num)*8-1;==31;
        while(temp>=0)
        {
            int value = num>>temp&1;
            printf("%d",value);
            temp --
        }

 

    8,字符串

    char name[8] = {'i','i','\0'};//严格意义上说 加\0才是真正的字符串
    char name[8] = "ii";//也是可以的

 

    9.strlen 计算字符串长度

        strlen函数声明在string.h文件中

        计算的字符串长度不包含\0

        1，计算的是字符数，并不是字数，一个汉字3个字符

        2，计算的字符不包括\0

        3，从某个地址开始数字符的个数，知道遇到\0为止 

    9,指针 ：

　　能够根据地址值(&变量) 找到对应的存储空间 并且修改值(*变量 =xx) 

    在函数内部 改变外部变量需要传递地址

    格式：变量类型  *变量名

    int *p; 定义了一个指针变量p，指针变量只能存储地址

    int *p; int a = 90; p =&a; *p =10;所以a=10；

    单独的*a  是访问a指向的存储空间地址

    指针变量所指向的变量必须 类型一致

    char c = 'a'; char *cc = &c; *cc = 'd'; //可以

    取值赋值都用 *变量

    清空指针 int *p; p= &d; p = 0;p=null;

    ::想要从函数内部改变外部值 

        1，调用方法必须传递变量地址 &变量

       ,2，函数形参 只有 指针 *变量 才能存储地址

        

    %d int,%f float\double,%ld long,%lld long long

    %c char %s 字符串 %zd unsigned long

    任何指针都占用8个字节

    

    int * p = &变量[0]  得到数组中第一个元素的地址

    *(p+1)得到 数组中的下一个元素 的值

    数组元素的访问方式

        1，数组名[下标] ages[i]

        2，指针变量名[下标] p[i]

        3，*(p+1)

    指针变量+1加多少取决于指针的类型

    

10 :变量的作用域

        1，局部变量：在函数内部定义的变量从定义变量开始一直到代码块结束

             没有固定的初始值

       2，全局变量：从定义一行开始 到文件结尾

            默认初始值为0

11:结构体

    定义结构体类型

    struct Date{
        int year;
        int month;
    };
    struct Date dt = {2014,4};//定义结构体变量

 

    补齐算法(对齐算法)

    结构体所占用字节空间 肯定是最大字节数的倍数

    2第二种定义结构体并声明变量

    Struct Student{
        int age;
        double height;
    } stu;

 

    3第三种 有坏处 每次定义必须重新写一次

    Struct{
        int age;
        char *name;
    } stu;

 

    结构体数组

    struct RankRecord records[3]={
        {1,"sss",222},        {1,"sss",222},        {1,"sss",222}
    }

 

    指向结构体的指针

    struct Student{int n;inta;};
    struct student stu = {1,22};
    struct student *p;
    p =&stu;

 

    调用: stu.a  stu.n

            (*p).a (*p).n

     最常用：p->a,p->n       

    结构体函数传值

    int test(struct student *p);

    结构体嵌套定义

    struct Date{int year;int month;int day;};
    struct Student{int no;struct Date birthday;};
    struct Student stu={1,{2014,2,3}};

 

    调用 stu.birthday.year

    

12:枚举

    enum Season{
        spring,summer,autumn,winter
    }

 

    定义变量enum Season s =  spring;

  

 

13:预处理指令

    所有预处理指令都以#开头

    宏定义只是文本替换 不具有运算功能

    #define String char*//把String 替换成char*

    a，不带参数的宏

        1，宏定义:  把代码中变量先替换成值

            #define 宏名称 值  //名称一般大写

            #define COUNT 6

        2,在代码翻译成01之前执行

        3,   预处理的位置是随便写的

        4,作用域：从编写一行开始 一直到文件结束

   b，带参数的宏定义

         

    #define sub(n1,n2) n1+n2
                int a =10;int b=20;
                intc = sub(a,b);

 

14: 条件编译

            #if(A==10)
                printf()
            #elif(A==5)
                printf()
            #else
                xxx
            #endif

 

            

15:文件包含

        不允许换换包含 a-->b b-->a 

        lisi.c //函数的编写

        lisi.h//函数的声明

        #include "lisi.h"

        保证不重复引用

        #ifndef LISI_H

        #define LISI_H

        int num(int a,int b);    

        #endif

16:typedef

    给类型定义别名

       1, typedef int MyInt;
        2,typedef struct Student{
            int age;
        } MyStu;
        3, typedef struct{
            int age;
        } MyStu;//不灵活

 

 

17: static,extern

    1,对函数有效

    2,对变量有效

    extern外部函数：定义的函数能被本文件和其他文件访问 默认是外部函数

    static内部函数：定义的函数只能被本文件访问

    变量也分内部外部

    static int b;本文件可访问使用 

                    在函数内部声明static变量时 只是延长声明周期

                    还是一个局部变量,没有改变变量的作用域

    extern int a;//声明外部变量

18:递归

 

       class Program
    {
        static void Main(string[] args)
        {
            //pow(1, 4);
            int num = pow(2, 2);
            Console.WriteLine(num);
            Console.ReadLine();
        }
        public static int pow(int num1,int count)
        {
            if (count <= 0) return 1;
                
            return pow(num1, count-1) * num1;
        }
    }