1.函数基础
//
// Created by billge on 2022/11/20.
//
#include <stdio.h>
/**
* x 形式参数
* @param x
* @return
*/
double F(double x){
return x*x + x+1;
}
double G(double x,double y,double z){
return x*x+y*y+z*z;
}
/**
* 函数基础
*/
int main(){
puts("Hello-word");
/**
* 2.0 是实际参数
*/
double result_f = F(2.0);
double result_g = G(3.0,4.0,5.0);
printf("result of f: %f\n",result_f);
printf("result of f: %f\n",result_g);
return 0;
}
2.函数的原型
//
// Created by billge on 2022/11/20.
//
#include <stdio.h>
/**
* 函数的原型
*/
void EmptyParamList() {
puts("Hello");
}
void EmptyParamListNew(void);
/**
* 原型
* 1.函数名
* 2.函数返回值类型，如果没有写，默认为int
* 3.函数参数列表，参数类型，和参数的顺序，参数形参名不重要
* @return
*/
int Add(int left, int right) { return left + right; };
int main(void) {
EmptyParamList();
//和C++的区别，如果调用的函数参数是void，则编译不通过
EmptyParamList(1);
EmptyParamList(1.0, "Helllo");
//函数调用
int result = Add(1, 2);
printf("result of add: %d\n", result);
return 0;
}
3.变量的类型和作用域
//
// Created by billge on 2022/11/20.
//
#include <stdio.h>
/**
* 变量的类型与作用域
*/
//文件作用域
int gloabl_var = 1;
void LocalStaticVar(void){
//静态变量
//文件作用域，不赋初始值，也会有初始值0
static int static_var;
//自动变量 auto
// 函数，块，作用域，没有初始值
int non_static_Var;//出了函数作用域就会被销毁
printf("static_var: %d\n",static_var++);
printf("non_static_Var: %d\n",non_static_Var++); //msvc运行调用会报错，gcc编译不会出错，但是会有意向不到的结果错误
}
double Add(double a, double b);
void CleanMemory(){
int eraser = -1;
}
//函数原型作用域，例如 size
double Sort(int size,int arrary[size]);
void PassByMemory(int parameter){
printf("%d/n",parameter);
}
//寄存器变量 : C语言编译完成生成了汇编指令
//装个插件：Compiler expoler 观察
//装完插件后，设置服务器地址:https://godbolt.org
void PassByRegister(register int parameter){
printf("%d\n",parameter);
}
int main(){ //函数作用域
//自动变量: 内存自动分配和自动销毁
auto int value = 0;
{
//块作用域
auto int a = 1;
}
if(value>0){
//块作用域
int is_value_equals_0 = 0;
}else{
gloabl_var =20;
}
return 0;
}
4.函数的变长参数
//
// Created by billge on 2022/11/21.
//
#include <stdio.h>
#include <stdarg.h>
/**
* 函数的边长参数
*/
void HandleVarargs(int arg_count, ...) {
//1.定义va_list 用于获取我们变长参数
va_list args;
//2.开始遍历
va_start(args, arg_count);
for (int i = 0; i < arg_count; ++i) {
//3.取出对应的参数，（va_list,type）
int arg = va_arg(args, int);
printf("%d : %d\n", i, arg);
}
//4、结束遍历
va_end(args);
}
int main() {
HandleVarargs(4,1,2,3,4);
return 0;
}
5.函数的递归
//
// Created by billge on 2022/11/21.
//
#include <stdio.h>
//函数的递归
/**
*
* 实现阶乘
* f(n) = nf(n-1)
* f(n-1) = (n-1)f(n-2)
* ......
* f(1)=f(0)
*
* 终止条件： f(0)=1 初值
*/
unsigned int Factorial(unsigned int n) {
if (n == 0 || n == 1) {
return 1; //f(0)=1, f(1)=1
} else {
return n * Factorial(n - 1);//f(n)=nf(n-1)
}
}
/**
* 通过迭代的方式实现阶乘 n!
*/
unsigned int FactorialByIteration(unsigned int n) {
unsigned int result = 1;
for (unsigned int i = n; i > 0; --i) {
//result = result * i;
result *= i; // n * (n-1)
}
return result;
}
/**
* 斐波那契数列规则：f(n)=f(n-1) + f(n-2)
* 初值：f(0)=0;f(1)=1
* @return
*/
unsigned int Fabonacii(unsigned int n) {
if (n == 0 || n == 1) {
return n;//f(0)=1, f(1)=1
} else {
return Fabonacii(n - 1) + Fabonacii(n - 2); //f(n) = f(n-1) + f(n-2)
}
}
/**
* 斐波那契数列 通过迭代方式实现
* @return
*/
unsigned int FabonacciByIteration(unsigned int n) {
if (n == 0 || n == 1) {
return n;
}
unsigned int last = 0;
unsigned int current = 1;
for (int i = 0; i < n - 1; ++i) {
unsigned int temp = current;
current += last;
last = temp;
}
return current;
}
/**
* 汉诺塔游戏：
1、有三根相邻的柱子，标号为A,B,C。
2、A柱子上从下到上按金字塔状叠放着n个不同大小的圆盘。
3、现在把所有盘子一个一个移动到柱子B上，并且每次移动同一根柱子上都不能出现大盘子在小盘子上方。
对于汉诺塔问题，可以分下面几种情况：
当只移动一个圆盘时，直接将圆盘从 A 针移动到 C 针。
若移动的圆盘为 n(n>1)，则分成几步走：
把 (n-1) 个圆盘从 A 针移动到 B 针（借助 C 针）；
A 针上的最后一个圆盘移动到 C 针；
B 针上的 (n-1) 个圆盘移动到 C 针（借助 A 针）；
每做一遍，移动的圆盘少一个，逐次递减，最后当 n 为 1 时，完成整个移动过程。
*
* @param n The count of plates
* @param src The source of the plates to move from
* @param dest The destination of th plates to move to
* @param tmp The temporary place to use
*/
void Move(int n, char src, char dest, char tmp) {
if (n == 0) return;
else if (n == 1) printf("%c--->%c\n", src, dest);
else {
Move(n - 1, src, tmp, dest); //n-1的盘子移动到临时的柱子上 Move(n-1,A,B,C)
Move(1, src, dest, tmp); //把剩下的最大的移动到目标位置上 Move(1,A,C,B)
Move(n - 1, tmp, dest, src); //把移动到临时柱子上的n-1个盘子移动到目标盘子上 Move(n-1,B,C,A)
}
}
int main() {
//阶乘打印
printf("0!: %d\n", Factorial(0));// 1
printf("1!: %d\n", Factorial(1));// 1
printf("2!: %d\n", Factorial(2));// 2
printf("3!: %d\n", Factorial(3));// 6
printf("5!: %d\n", Factorial(5));// 120
printf("10!: %d\n", Factorial(10));//3628800
printf("10! by Iteration: %d\n", FactorialByIteration(10));//3628800
//斐波那契打印
printf("Fabonacii(0): %d\n", Fabonacii(0));// 0
printf("Fabonacii(1): %d\n", Fabonacii(1));// 1
printf("Fabonacii(2): %d\n", Fabonacii(2));// 1
printf("Fabonacii(3): %d\n", Fabonacii(3));// 2
printf("Fabonacii(5): %d\n", Fabonacii(5));// 5
printf("FabonacciByIteration(5): %d\n", FabonacciByIteration(5));// 5
//汉诺塔移动过程模拟打印
Move(3, 'A', 'C', 'B'); //A--->C A--->B C--->B A--->C B--->A B--->C A--->C
return 0;
}
