[C++知识库]C语言整理

函数

C语言中函数的调用

作用

避免出现代码复制的情况，提高代码质量，方便日后维护。

举例：

#include<cstdio>
int i,sum;
for(i=1,sum=0;i<=10;i++){
 ? ?sum+=i;
}
printf("%d到%d的和是%d",1,10,sum);
for(i=20,sum=0;i<=30;i++){
 ? ?sum+=i;
}
printf("%d到%d的和是%d",20,30,sum);
for(i=35,sum=0;i<=45;i++){
 ? ?sum+=i;
}
printf("%d到%d的和是%d",35,45,sum);

以上代码可以改成以下代码：

void sum(int begin,int end){
 ? ?int i,sum=0;
 ? ?for(i=begin;i<=end;i++){
 ? ? ? ?sum+=1;
 ?  }
 ? ?printf("%d到%d的和是%d",begin,end,sum)
}
int main()
{
 ? ?sum(1,10);
 ? ?sum(20,30);
 ? ?sum(35,45);
 ? ?return 0;
}

可见，函数调用可以有效的避免代码重复的情况。

函数的组成

void sum(int begin,int end){
 ? ?int i,sum=0;
 ? ?for(i=begin;i<=end;i++){
 ? ? ? ?sum+=1;
 ?  }
 ? ?printf("%d到%d的和是%d",begin,end,sum)
}

以以上代码为例，"void sum(int begin,int end)"为函数头，其中"void"为返回类型，"sum"是函数名，括号里的是参数表，而这一部分:

{
 ? ?int i,sum=0;
 ? ?for(i=begin;i<=end;i++){
 ? ? ? ?sum+=1;
 ?  }
 ? ?printf("%d到%d的和是%d",begin,end,sum)
}

是函数体，函数的主要部分。

函数的参数和变量

传值

每个函数有??的变量空间，参数也位于这个独?的空间中，和其他函数没有关系

过去，对于函数参数表中的参数，叫做“形式参数”，调?函数时给的值，叫做“实际参数” 由于容易让初学者误会实际参数就是实际在函数中进?计算的参数，误会调?函数的时候把变量?不是值传进去了，所以我们不建议继续?这种古?的?式来称呼它们

我们认为，它们是参数和值的关系

注意：函数是不允许函数嵌套的

数组

定义：创造出一系列的"房间"，用于储存常量。 （指针相当于房间号）

两数组之间需要赋值只能用遍历的方式如：

int a[10];
int b[10];//若要使两数组中的值相等
for(int i=0;i<10;i++){
 ? ?a[i]=b[i];
}

二维数组

如：

int a[3][5]

可以理解为三行五列的表格，具体化如下：

数组的妙用

在定义中说了，数组可以储存常量，也就是说，数组可以用来记数。如题

链接：登录—专业IT笔试面试备考平台_牛客网 来源：牛客网

宇宙集团对QIT的课程做了一个满意度调查，一共在校园内抽取了N个同学，对本学期的M种课程进行满意度调查。宇宙集团的小Y想知道，有多少门课是被所有调查到的同学都喜欢的。

#include<stdio.h>
int main (){
 ? ?int A,N,M,z,x=0;
 ? ?int a[1500]={0};
 ? ?scanf("%d%d",&N,&M);
 ? ?for(int i=0;i<N;i++){
 ? ? ? ?scanf("%d",&A);
 ? ? ? ?for(int j=0;j<A;j++){
 ? ? ? ? ? ?scanf("%d",&z);
 ? ? ? ? ? ?a[z]++;
 ? ? ?  }
 ?  }
 ? ?for(int h=0;h<=M+1;h++){
 ? ? ? ?if(a[h]==N){
 ? ? ? ? ? ?x++;
 ? ? ?  }
 ?  }
 ? ?printf("%d",x);
 ? ?return 0;
}

用数组的下标来作为需要记的数，可以做到意想不到的效果。

函数递归

递归

递归就是一个函数在它的函数体内调用它自身。执行递归函数将反复调用其自身，每调用一次就进入新的一层。递归函数必须有结束条件。 当函数在一直递推，直到遇到墙后返回，这个墙就是结束条件。 所以递归要有两个要素，结束条件与递推关系

PS：递归的时候，每次调用函数，计算机都会为这个函数分配新的空间，这就是说，当被函数返回的时候，调用函数中的变量依旧会保持原先的值否则也不可能实现方向输出。

例题

• 计算n的阶乘

  #include <stdio.h> 
  int factorial(int n)
  {
   ? ?int result;
   ? ?if (n<0) ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?//判断例外
   ?  {
   ? ? ? ?printf("输入错误!\n");
   ? ? ? ?return 0;
   ?  } 
   ? ?else if (n==0 || n==1)
   ?  {
   ? ? ? ?result = 1; ?//回推墙
   ?  }
   ? ?else
   ?  {
   ? ? ? ?result = factorial(n-1) * n; ?//递推关系，这个数与上一个数之间的关系。
   ?  }
   ? ?return result;
  }
  ?
  int main(){
   ? ?int n = 5; ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?//输入数字5，计算5的阶乘
   ? ?printf("%d的阶乘=%d",n,factorial(n));
   ? ?return 0;
  }
  ?

递归必须要有结束条件

• 斐波那契数列

  所谓斐波那契数列，就是如以下数列的数列（废话文学）

  0,1,1,2,3,5,8,13,21 ......

  这个数列在第三项开始，起第n项值等于（n-1）+（n-2）的值。于是又有：

  #include <stdio.h>
  
  long sum( long num )
  {
      if ( num == 0 || num == 1 )
      {
          return num;
      }
      else
      {
          return sum( num -1 ) + sum( num -2 );
      }
  }
  
  void main()
  {
      long number;
      puts("请输入一个正整数: ");
      scanf("%ld", &number);
      printf("斐波那契数列第%ld项为: %ld\n", number, sum( number ) );
  
  }
  

  ##

特点

1. 每一级函数的变量互不干扰，如阶乘算法

2. 每一次调用都会进行一次返回，如阶乘每一次都会返回。

3. 递归函数中，位于递归调用前的语句和各级被调用函数具有相同的执行顺序；

4. 递归函数中，位于递归调用后的语句的执行顺序和各个被调用函数的顺序相反；

5. 递归函数中必须有终止语句。

   总结：自我调用且有完成状态。

效率

系统栈（也叫核心栈、内核栈） 是内存中属于操作系统空间的一块区域，其主要用途为： (1)保存中断现场，对于嵌套中断，被中断程序的现场信息依次压入系统栈，中断返回时逆序弹出； (2)保存操作系统子程序间相互调用的参数、返回值、返回点以及子程序(函数)的局部变量。

用户栈 是用户进程空间中的一块区域，用于保存用户进程的子程序间相互调用的参数、返回值、返回点以及子程序(函数)的局部变量。 我们编写的递归程序属于用户程序，因此使用的是用户栈。

栈溢出 函数调用的参数是通过栈空间来传递的，在调用过程中会占用线程的栈资源。而递归调用，只有走到最后的结束点后函数才能依次退出，而未到达最后的结束点之前，占用的栈空间一直没有释放，如果递归调用次数过多，就可能导致占用的栈资源超过线程的最大值，从而导致栈溢出，导致程序的异常退出。

PS:栈的概念会在下面进行叙述。

特点

循环能干的，递归也能干，反过来不一定，当然能用循环干的尽量不用递归

指针

由"&"和某些变量组成，其中&符号用于取地址。但是有些不能如：

• （a+b）

• （a-b）

• a++

• ++a

可以取以下地址：

• 变量地址

• 相邻变量的地址

• &的结果的sizeof

• 数组地址

• 数组单元的地址

• 相邻的数组单元的地址

所谓指针，就是储存地址的变量，如：

int i;
int* p=&i;
int* p,q;//注意，这里的变量q不属于指针，如果要使q变为指针，要变为int* p,*q.
int *p,q;//同上。

那么，似乎指针和普通的变量初始化差不多，那我们为什么要费这么大劲去做一个指针呢？

指针的真正作用在于它可以使在子函数里的变量访问到主函数的变量，举个例子：

#include<cstdio>
void f(int *p);
void g(int k);
int main (void){
    int i=6;
    printf("&i=%p",&i);
    f(&i);
    g(i);
    return 0;
    
}
void f(int *p){
    printf("p=%p\n",p);
    printf("*p=%d\n",*p);
}
void g(int k){
    printf("k=%d",k);
}

输出结果是：

&i=0xb5ff51d70
 p=0xb5ff51d70
*p=6;
k=6

可以看到，i的地址与p的地址相同，i的值与*p的值相同。 那接下来，我们就要做一个邪恶的事情：改变 * p的值。然后观察i的值会不会变。于是有：

#include<cstdio>
void f(int *p);
void g(int k);
int main (void){
    int i=6;
    printf("&i=%p",&i);
    f(&i);
    g(i);
    return 0;
    
}
void f(int *p){
    printf("p=%p\n",p);
    printf("*p=%d\n",*p);
    *p = 26;//改变*p的值
}
void g(int k){
    printf("k=%d",k);//因为函数g（），所以g函数会输出i的值
}

输出结果：

&i=0xb5ff51d70
 p=0xb5ff51d70
*p=6;//值不变是因为f函数没有二次调用
k=26

k=26,意味着i的值被改变了。 我们都知道，在C中，函数调用中参数转移时一种值的传递，我们把值传进了函数，所以函数的参数与他们调用的地方没有任何关系。现在，时代变了。我们仍然坚持说，这种情况下，仍然时值的传递。只不过&i的地址值传进了f函数中，但是因为传进来的是地址，所以我们依然可以*P这个地址去访问i变量，从而改变它。所以，指针赋予了变量接触函数外变量的途径。所以呢，我们就可以同过指针把函数值待回到原函数。

是不是很懵？总结一下：

我们可以现象出一个房间，而这个房间就是计算机的储存空间，而这个空间可以有多层楼，有很多房间。楼就是“函数”，而房间就是变量“住”的地方，每个房间都有地址，而门牌号，而门牌号就是告诉你地址的工具，也就是“指针”。

所以啊，我们可以通过门牌号（指针），找到房间（变量），从而改变他，又因为房间在同一空间下，所以会无视函数间的阻隔。

Java学习

特性与优势

• 简单性（c++纯净版，没有头文件，没有指针运算）

• 面向对象

• 可移植性 （跨平台性）

• 高性能

• 分布式动态性

• 多线程 （例如同时看视频和听音乐）

• 安全性

• 健壮性

Java的三大版本

• Java SE：标准版（桌面程序，控制台开发.....)

• Java ME：嵌入式开发（手机，小家电.....)（基本不用）

• Java E E： E企业开发（web端开发，服务器开发....）

J D K,J R E ,J V M

• J D K ：Java Development Kit（工具）

• J R E ：Java Runtime Environment（环境）

• J V M ：Java Virtual Machine（模拟机）

PS：从上至下呈包含关系，也就是J D K包含J R E ，J R E 包含J V M，再简单一点就是J D K是爷爷，J R E是爸爸，J V M是孙子。

Hello world

public class world{
    public static void main(String[] args){
        System.out.print("Hello world!");
    }
}

最简单的程序。

常见的Dos指令

• 常用的Dos命令盘符切换: C: D: E:

• 查看当前目录下的所有文件 dir

• 切换目录: cd (change directory)

• 跨盘符切换: cd + /d + 文件名;

• 同级目录切换:先返回上一级目录: cd …再进入想进入的目录 cd + 文件名

• 清理屏幕: cls(clear screen)

• 退出终端: exit

• 查看电脑的 ip: ipconfig

• 很常用的 windows程序: 计算器(calc), 记事本(notepad), 画图工具(mspaint)

• ping命令: 测试网络是否正常

• 创建文件夹: md + 文件夹名

• 删除文件夹: rd + 文件夹名

• 创建文件: cd>文件名.扩展名

• 删除文件: del + 文件名