C重要概念及难点

C第一二天

1、Unix的特点：

1可以有多个用户在同一系统上（多用户）

2可以同时运行多个程序（多任务）

3维护权限,确定哪些用户可以访问哪些（权限）

4分配每个用户可以使用的磁盘空间量（分配空间）

5对于隐藏文件只允许特定的用户访问（隐藏文件的权限）

 

 

ls：显示当前目录下的文件（不包含隐藏文件）

ls -a 显示当前目录下的所有文件，包含隐藏文件（.xxx 类型的为隐藏文件）

ls -l 以详细方式列出当前目录的内容（文件的大小、名称、最后修改时间等内容）

 

cd/cd~回到主用户目录

cd．  当前目录

cd .. 返回上一级目录

cd ~/homework 回到homework（指定文件）

 

mk/rmdir homework 创建/删除目录homework

rm/rm –i/-f/-r：删除文件或目录

 

pwd 显示当前路径

 

clear 清屏 （快捷键 ctr+l）

cat 文件名 查看文件内容

C第三天

const 数据类型 变量名 = 表达式   const float PI =3.141569 ;等价于#define PI 3.141569  （宏替换）

特点：

1、  修饰的变量必须是常量

2、  声明常量必须初始化

3、  常量不能被修改

 

 

输出格式：printf（format string(格式化字符串),data list (数据表)）；

输入格式：scanf（format string(格式化字符串)，address list (地址表)）；

scanf ("%d%f",&i,&p) ;   //%d和%f中间不能空格和加入“，”或加\n（无论中间还是后面） （不能添加任何东西）

printf ("%d\n%f",i,p) ;  \n中间后面可以添加

 

 

枚举类型的使用（作用：可读性好）（表示一个范围，如日期，年份，星期。。。。）

1、先定义枚举类型

2、枚举变量的声明

3、枚举变量的初始化

enum suit {clubs,diamonds,hearts,spades} ;       /*枚举类型的定义，定义一个suit类型*/

         enum suit card;                              /*枚举变量的声明*/

         card = clubs;                                /*枚举变量的初始化*/

switch (card)

         {

         caseclubs:

         ………

}

 

 

 

数组类型三种方式

1、int a[5] = {100,200,300,400,500} ;  

2、int a[5];      /*数组变量a的声明*/

  

         a[0] = 100;    /*初始化*/

3、scanf("%d",&a[0]) ;

         a[1]= 200 ;

         a[2]= 300 ;

         a[3]= 400 ;

         a[4]= 500 ;

8、变量名的规则

1、由下划线、字母、数字，但开头必须是下划线或字母
2、C语言是区分大小写的
3、不能使用C里面的关键字作为标识符

变量初始化的三种方式

1、  在编写代码时声明

int x = 5；

2、  运行时通过运用表达式初始化

X=5

3、  运行时通过输入声明

scanf （”%d”,&x）；

C第四天

1、/（取整）或 %（取余）运算符，除数不能为0；

2、%两边只能为整数，不能为小数，注意它定义的数据类型；

 

自增自减运算符（i++ i-- ++i --i）

特点：前置自增自减：先用i赋值，再自增/减1

后置自增自减：先自增自减1，后用增减过后的值i赋值

 

三目运算符的应用：

表达式为：(表达式1？表达式2：表达式3)

先求解表达式1，

若其值为真（非0）则将表达式2的值作为整个表达式的取值，

否则（表达式1的值为0）将表达式3的值作为整个表达式的取值。

(a > b) ? a :(b >c) ? b : c

当一个表达式中出现多个条件运算符时，应该将位于最右边的问号与离它最近的冒号配对，并按这一原则正确区分各条件运算符的运算对象。

 

逗号运算符

多个表达式可以用逗号分开，其中用逗号分开的表达式的值分别结算，但整个表达式的值是最后一个表达式的值。

 

C第五天

一．条件判断结构

1、if（表达式1） 

  else（表达2）

 

1、多层else if

if（表达式1）

    语句1；

  else if （表达式2） 

    语句2；

  else if （表达式3）

    语句3；

   .......

  else if （表达式n）

    语句n

  else

语句m；

2、3、多层if

if( )

…..

if( )

……

 

4、switch语句

 

注意：
1、break不属于switch
2、如果没有break后面的printf语句都执行
3、Switch语句要和break语句配合使用。
4、break：独立构成一条语句
5、switch（）括号里的值是普通值，常量值，不是判断，真或者假。
6、switch中的值和case的值匹配，如果匹配成功则输出break后面的内容。

switch （表达式）

{

      case  const-expr：语句1；

      case  const-expr：语句2；

}

switch (grade)

         {

         case 'A':

                   printf ("your mark isbetween 90 and 100\n");

            break;

         case 'B':

                   printf ("your mark isbetween 80 and 90\n");

            break;

default:

                   printf ("your mark isnot successful!\n");

                   break;

         }

循环结构 

3、for循环

for循环：(前置测试循环)
expr1:循环变量初始化
expr2:执行条件判断
expr3:修改循环体变量的值

 

for （表达式1；表达式2；表达式3）     //先判断再执行

{

语句；

}

4、while循环

 

表达式1

while （表达式2 //布尔型表达式条件为真值，执行循环体为假值跳出循环。） //先判断再执行

{ 

执行语句；

表达式3

}

int i = 0;     //表达式1

         while (i < 6)   //表达式2

         {  

                  

                   printf ("count =%d\n",i);   //循环语句

                   i++;      // 表达式3

         }

 

5、do while循环

特点：
1、循环体至少执行一次

表达式1                    //先执行后判断

do {  

执行语句；

表达式3                                                           

 }while（表达式2 ）；

int i = 0;       //表达式1

         do{

                   printf ("count =%d\n",i);    //循环语句

                   i++;       //表达式3

         } while(i < 3);   //表达式2

4、转向语句
Break and continue
Continue:作用：终止本次循环，重新下一次循环
Break：跳出当前循环体语句。

 

 

第六章函数（什么是函数？有零个或者多个输入，加工后只有一个输出）

自上而下的设计
1、主模块划分为小模块，每个小模块又划分为更小的模块
3、函数的主模块
1、建立在C的基础之上
2、每个函数都有一个主函数
3、主模块可划分成子函数

特点：

1、使程序组织化开发，方便代码的复用

2、开发和测试每一块程序，使程序模块化；

3、提高程序的运行效率；

4、程序清晰可见。

函数的定义

1、函数声明：

返回值类型函数名（参数列表）

{

声明变量和执行语句

}

2、函数用到的地方

    1、函数声明

   2、函数调用

   3、函数的实现

void greding(void);   /*函数的声明*/

int main ()

{

         greding ();       /*函数的调用*/

         return 0;

}

void greding(void)   /*函数的实现*/

{

         printf ("Hello World!\n");

}

3、函数参数

实参：被传递的参数（可以为变量也可以为常量）
形参：用于接收实参的值为形参

主调函数：调用函数的外部的函数

被调函数：实现所需功能的函数

  1、传参方式：
     1、传值
     2、传有效内存地址
     3、引用传递（c++中用到）
  2、传值的特点
     1、在主调函数中将实参的值拷贝给被调函数的形式参数
     2、参数的传递时单向的（实参传给形参）
     3、函数中形参的改变不会影响到实参的变化。

 

3、double  art(double,double);

形参名称可以不写，类型必须写，声明时可不写，实现时必须写，声明形参的目的是告诉系统要分配多少内存。

   4、默认参数

a)是指在函数声明是赋值给形参的值

五、内联函数

含义：用函数实现语句替换函数调用语句
Inline int func(int a,int b)
1、优点：节省程序执行时间，程序执行效率高
2、缺点：增加了额外的内存占有率。
3、它不寻找函数。（以函数的被调代码替代函数的执行语句）
六、函数的重载
定义：重新定义，重新加载
特点：1、以函数名相同，参数不同（形参类型、个数）

 

C第六天

1、指针定义

指针的定义：指针是一个变量，它的值是另外一个变量有效地地址。

 

变量包括变量的值、变量的存储地址、变量名。

 

char achar=‘G’；

char* p = &achar；

char*:指针变量p的数据类型

p：指针变量名（它的数据类型名为char*）

char：表示指针变量p指向那个变量（achar）的数据类型

*：表示变量p在这是一个指针

p指向achar，不能说p指向achar的地址。

 

操作符：&（取地址运算符） %p（打印地址）以十六进制打印出

#include<stdio.h>

 

int main()

{

         chara = 'A';

         char* p = &a;  //等价于 char*  p； p=&a；

 

   printf ("a变量本身的地址：%p\n",&a);     // printf ("p变量的值：%p\n",p); 结果一样

         printf("a变量本身的地址：%d\n",&a);     //printf ("p变量的值：%d\n",p);结果一样

         printf("p变量本身的地址：%p\n",&p);

         printf("p变量本身的地址：%d\n",&p);

         printf("a变量的值：%d\n",a);    //以十进制输出

         printf("a变量的值：%p\n",a);    //以十六进制输出

         return0;

 

}

 

 

 

 

指针占用指针变量4个字节

 

/*指针占字节的大小*/

#include<stdio.h>

int main()

{

         chara = 'A';

         char*p = &a;

         printf("size:%lu\n",sizeof (p));

         printf("size:%lu\n",sizeof (double*));

         printf("size:%lu\n",sizeof (char*));

         printf("size:%lu\n",sizeof (double*));

         return0;

 

}

 

2、指针变量

指针变量的特点：

1、可以包含另一个变量的一个有效地址

2、值可以改变

3、一个指针可以指向指定类型

4、多个指针可以共用一个储存空间/内存。

 

 

3、变量的访问

1、* 解引用运算符（指针访问运算符  特点：求解指针变量所指向那个变量的值）

2、引用经常被认作为读取另一个变量的内容。

int* p= &a;  //等价于 int* p; p =&a;

         intc;

         c = *p + 43;    //*p等价于a  

 

 

//*p=8；       //*p位置赋值在左边为写 

//*&x=*q+*p;   //*p位置赋值在右边为读   对同一个变量，取地址&和解引用*抵消

//x=*q **p;

5、无初始化的指针（不能对未被初始化的指针解引用，即使初始化为NULL或0时，也不能解引用，因为NULL和0都为空指针，不是有效地址。

 

#include<stdio.h>

 

int main()

{

         int *p;    // int* p=NULL;

         //*p = 10;

         printf("%d\n",*p);

         return0;

 

}

结果失败：原因如上

7、指针作为参数

传值：形参的改变不会影响到实参

 

/*传值方式的传递*/

#include<stdio.h>

 

void exchange(int a,int b);

 

int main()

{

         inta = 10;

         intb = 20;

         exchange (a,b);       //实参的值传给了形参

         printf("%d %d\n",a,b);

         return0;

 

}

 

void exchange (int a ,int b)

{

         inttemp = 0 ;

         temp = a;

         a = b ;

         b = temp ;   //形参值的改变不会影响到实参

}

传指针的特点：

1、  将主调函数当中实参指针变量的值拷贝一份赋值给被调函数形参指针变量。

2、  实参指针变量的值传递给形参指针变量的值，该值单一。

3、  在被调函数中用形参指针变量可以间接的访问实参指针变量所指向的变量。

 

传指针：形参变量可以间接的访问实参指针变量所指向的变量

 

/*传指针方式的传递*/

#include<stdio.h>

 

void exchange(int* ,int*);

 

int main()

{

         inta = 10;

         intb = 20；

int *pa =&a;

int *pb =&b;

         exchange (pa,pb);

         printf("%d %d\n",a,b);

         return0;

 

}

 

void exchange (int *a ,int *b)

{

         inttemp = 0 ;

         temp = *a;

         *a = *b ;

         *b = temp ;

   

}

C第七天

8、返回指针变量

 

/*利用指针变量（传指针变量的有效地址）求最小值*/

#include<stdio.h>

int* min(int* a, int *b);

int main ()

{

         intx,y;

         int *z;

         scanf("%d%d",&x,&y);

         z =min(&x,&y);          //传指针变量方式调用min函数的有效地址

         printf("%d%\n",*z);

}

int* min(int* a, int *b)

{

         int *c;

c=(*a<*b?a:b);

         return c;       //return (*a<*b?a:b)

}

 

 

不能返回局部变量指针/地址

#include<stdio.h>

 

float *mistake();

 

float *mistake()

{

float temp = 12; 

//return &temp;   //int *p = &temp；

 

//return  p；   //不能返回局部变量的指针/地址

}

 

int main()

{

 float* p = mistake();

 printf( "%f\n", *p);

 return;

}

虽然结果为12.0000，但是取的是内存里面的内容12.0000。不是在自定义函数（被调用函数）里面调用它的值。

9、指向指针的指针

int **p：

p的数据类型为int**类型

p指向另一个变量名的数据类型为int*

 

/*多维指针的利用*/

#include<stdio.h>

int main ()

{

         /*int a = 50;*/

         //int *p =&a;

         //int **q=&p;

         int a;

         int *p;

         int **q;

        

         a = 50;

         p = &a;

         q = &p;

         printf("%d\n",a);

         printf("%d\n",*p);

         printf("%d\n",**q);

         return0;

}

多维指针

#include<stdio.h>

 

int main ()

{

         /*inta = 50;*/

         //int*p = &a;

         //int**q =&p;

         inta;

         int *p;

         int **q;

         int ***r;

 

         p= &a;

         q= &p;

         r= &q;

         scanf("%d",&a);

         /*scanf("%d",p);

         scanf("%d",*q);

         scanf("%d",**r);*/

        

         printf ("%3d%3d%3d%3d\n",a,*p,**q,***r);

         return0;

}

10、字节大小和兼容性

 

/*求char、int、double，char*，int*，double* */

#include<stdio.h>

 

int main ()

{

         char c;

         char* pc;

         int a;

         int* pa;

         double x;

         double* px;

 

         printf("%3d%3d%3d\n",sizeof (c),sizeof(pc),sizeof (*pc));  // *pc=c=1

         printf("%3d%3d%3d\n",sizeof (a),sizeof(pa),sizeof (*pa));  //*pa=a=4

         printf("%3d%3d%3d\n",sizeof (x),sizeof(px),sizeof (*px));  //*px=x=8

         return0;

}

 

 

11、指针和数组

 

/*输出&a[0],a*/

#include<stdio.h>

 

int main ()

{

         int a[5];

         printf ("%p%p\n",&(a[0]),a);   //输出a[0]的首地址

         return0;

}

表达式a相当于指向数组首元素的指针

a的值等于首元素的地址

 

/*输出a[i],*p*/

#include<stdio.h>

 

int main ()

{

         inta[5]={11,22,33,44,55};

         int*p = a;   //等价于int *p =a[0]

         inti = 0;

         printf ("%d %d\n",a[i],*p);   //输出a[0]的首地址，a[i]可以用a[0]但是去掉int i=0；或*s

//printf ("%d %d\n",*a,*p);

// printf ("%d %d\n",a[0],*p);

         return0;

}

 

 

/*输出数组其他的元素，除首元素*/

#include<stdio.h>

 

int main ()

{

         inta[5]={11,22,33,44,55};

         int*p ; 

         p = &a[1];

         printf ("%d %d%d\n",*(a+1),*(p-1),*a);   //（p-1：指上一元素 p+1：指下一元素）

         return0;

}

 

#include<stdio.h>

 

int main ()

{

         intint_array[5] = {11,22,33,44,55};

         int (*p)[5] ; 

         p = &int_array;    //int (*p)[5] = &int_array;; 

         printf("%p\n",p);  //首元素的地址&int_array[0]

         printf ("%p\n",int_array);   //首元素的地址&int_array[0]

         printf("%p\n",&int_array);  //首元素的地址&int_array[0]

         return0;

}

 

指针数组和数组指针的区别

指针数组：int *  p[5];      //数组名p指向的是一个int*类型的元素，

数组指针：int  (*p)[5] ;    //指针变量p指向的是一个int类型的数组

从符号的优先级也可以考虑：（） >[  ] >*

 

注：数组名不可以做自增运算，因为数组变量名的值是个常量

指针变量可以做减法运算，其值为偏移量。

 

#include<stdio.h>

 

int main ()

{

         chara[3]={'a','b','z'};

         intb[3]={4,5,6};

         floatc[3]={7.1,8.2,9.3};

         char* pa = a + 1;  //char* pa = &a[1]

         int* pb = b + 1;    //char* pb = &b[1]

         float* pc = c + 1;  //char* pc = &c[1]

          printf ("%c %d %f\n",*pa,*pb,*pc);   //等价于printf ("%c %d %f\n",a[1],b[1],c[1]);

或者// printf ("%c %d%f\n",*(a+1),*(b+1),*(c+1));

         return0;

}

 

/*数组的指针变量解引用*/

#include<stdio.h>

 

int main ()

{

         intx[10]={1,2,3,4,5,6,7,8,9,10};

         int*p ;

         p=&(x[5]);   //等价于 int* p=&(x[5]);

         p+=3;

         printf("%d\n",*p);

         p-=7;

         printf("%d\n",*p);

         p++;

         printf("%d\n",*p);

         p--;

         printf("%d\n",*p);

         return0;

}

 

#include<stdio.h>

 

int main ()

{

         intx[10]={1,2,3,4,5,6,7,8,9,10};

         int* p ;

         p = x;  //x首元素的地址传给p;

         p++;

         printf("%d\n",*p);

         p--;

         printf("%d\n",*p);

         return0;

}

 

13、传参

传值方式：

#include<stdio.h>

 

void f (int x);

int main ()

{  

         inta = 3;

         f(a);

         printf("%d\n",a);

         return0;

}

void f (int x)

{

         x=x+1;

}

传指针方式：

#include<stdio.h>

 

void f (int *x);

int main ()

{  

         inta[2]={1,2} ;

         int*pa;

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

   f(pa);//等价于f(a);

         printf("%d\n",*pa);//printf ("%d\n",*a);

         return0;

}

void f (int x)

{

         x=x+1;

}

传数组方式：

#include<stdio.h>

 

void f (int *x);

int main ()

{  

         inta[2]={1,2} ;

         int*pa;

         pa= a;

   f(pa);  //&a[0]

         printf("%d  %d\n",*(pa+1),a[1]);

         return0;

}

void f (int *x)

{

         x=x+1;    //&a[1]

         *x=100;   //把100赋值给*x

}