//常量是程序运行期间不能改变的量 比如：3, 4.5, ‘a‘
//变量是一块存储区域，程序运行期间可以发生改变的量。
//声明一个变量的语法格式:数据类型 变量名 ＝ 初值;
//相同数据类型的变量可以放到同一行去声明
//变量名的命名规则:
/**
* 1、以数字、字母、下划线、$组成，且数字不能开头
lanou3g、lanou_3g、3glanou、_lanou3g
2、不能与系统保留字重名
3、变量名不能重复命名
4、见名知意，驼峰法
*/
/*
int a, b, c = 0;
int numberOfStudent = 47;
numberOfStudent = 50;
char gender = ‘m‘;
float price = 10.0;
*/
//交换两个整形变量的值
//位运算异或^ 运算法则为 相同为0，不同为1
/*
int a = 10;//1010
int b = 8;//1000
a = a ^ b;//0010
b = a ^ b;//1010
a = a ^ b;//1000
*/
/*
2、
a = a + b;
b = a - b;
a = a - b;
*/
/*
1、
int c = 0;//第三方变量，做暂存。
c = a;
a = b;
b = c;
*/
//递增、递减。
//++或者-- 在前 先加或者先减，++或者-- 在后，后加或者后减
// int a = 10;
// a ++;//a = a + 1
/*
int b = a ++;
int c = ++ a;
int d = a --;
int e = -- a;
*/
//占位符
//格式串中的占位符，一定要与格式串后面的表达式一一建立对应关系，并且，表达式与表达式之间用逗号隔开。
/*
printf("何一凡\\ 中二病%% 晚期,年龄 %d岁,性别 %c,成绩 %.2f",22, ‘f‘, 59.9);
short a = 10;
printf("\n,%d",a + 10);
printf("\n%s","iPhone");
printf("\n%o",10);
printf("\n%4d",10);
*/
/*
//声明一个整型变量a
char a = ‘0‘;
char c = ‘0‘;
//a接收输入的值
scanf("%c",&a);
scanf("%c",&c);
// char c1 = getchar();
//打印 a + 10的结果
printf("%c %c",a, c);
*/
/**
* 1、声明变量，来存储scanf从键盘缓存区中取出来的值
2、提醒用户应该输入什么内容
3、从键盘缓存区扫描出相对应的值，交给变量存储
4、使用变量完成相对应的功能。
*/
/*
int a, b = 0;
printf("请输入两个整型数字(空格隔开):");
scanf("%d%d",&a, &b);
printf("%d",a + b);
*/
//输入两个数，求百分比
/*
float a, b = 0.0;
printf("请输入两个浮点数(中间以空格隔开):");
scanf("%f%f",&a, &b);
printf("%.1f%%",a / b * 100);
int c, d = 0;
printf("请输入两个整型数(中间以空格隔开):");
scanf("%d%d",&c, &d);
float result = c / (float)d * 100.0;
printf("%.1f%%",result);
*/
char c = ‘a‘;
char c1 = c - 32;
printf("%c",c1);
int $c = 10;
$c = 11;
return 0;
}
//第二节
//BOOL数据类型是一种表示非真即假的数据类型，只有YES和NO两种情况，YES(1)代表真，NO(0)代表假。
//BOOL数据类型的变量可以用来接收表达式的返回值，只要返回值非0，那么BOOL类型的变量的值就为YES。
//BOOL变量的命名通常以is、has、can开头
/*
1、isBoy,isThin,isTall
2、hasMoney,hasBoyfriend,hasBeauty
3、canEat,canSleep,canFly
*/
// BOOL isTrue = YES;
//查看数据类型或者变量所占字节数的函数为sizeof()
//%lu 为 unsigned long占位，无符号长整型。
// printf("%lu",sizeof(double));
//关系运算符 > < >= <= == !=
//逻辑运算符 && || !
//通过关系运算符、逻辑运算符连接的表达式，结果用BOOL值接收，表示非真即假。
/*
1、逻辑与 && 同真为真，一假则假
2、逻辑或 || 同假为假，一真即真
3、逻辑非 ！ 将表达式的结果取反
*/
/*
int a = 10, b = 9;
BOOL isTure = a < b && a ++;
printf("isTure = %d, a = %d, b = %d",isTure, a, b);
*/
//if语句
//第一种形式
/*
if(条件表达式) {
语句;
}
如果条件表达式为真，执行语句，否则跳过if语句，执行下面的语句。
*/
/*
if(条件表达式) {
语句1;
} else {
语句2;
}
如果条件表达式为真，执行语句1，否则执行语句2
*/
/*
if (条件表达式1) {
语句1;
} else if (条件表达式2) {
语句2;
} else {
语句3;
}
如果条件表达式1为真，执行语句1，如果条件表达式1为假并且条件表达式2为真执行语句2，如果条件表达式1为假并且条件表达式2也为假执行语句3
*/
//控制台输入一个字符，如果输入的是m，则输出男性，否则什么都不输出。
//声明一个字符型变量
// char c = ‘0‘;
//
// //提醒用户输入
// printf("请输入一个字符:");
//
// //扫描接收输入的字符
// scanf("%c",&c);
//if
/*
if (‘m‘ == c) {
printf("男性\n");
}
*/
//如果从控制台输入一个字符，如果输入的是m，则输出男性，否则输出女性，那怎么实现呢？
/*
if (‘m‘ == c) {
printf("男性\n");
} else {
printf("女性\n");
}
*/
/*
输入一个年份，判断该年份是否是闰年？如果是闰年，则输出该年是闰年，否则输出该年不是闰年。
满足闰年的条件：
1. 能被400整除。(如2000年是闰年，1900年不是闰年)
2.能被4整除，但是不能被100整除。(如2004年就是闰年，2010年不是闰年)
*/
/*
int year = 0;
printf("请输入一个年份:");
scanf("%d",&year);
BOOL is400 = 0 == year % 400;
BOOL is4 = 0 == year % 4;
BOOL is100 = 0 == year % 100;
if (is400 || (is4 && !is100)) {
printf("%d年是闰年",year);
} else {
printf("%d年不是闰年",year);
}
*/
//条件运算符
/*
int a = 9, b = 10, c = 8;
int max = a > b ? a : b;
max = max > c ? max : c;
*/
/*
if (a > b) {
max = a;
} else {
max = b;
}
*/
/*
从控制台输入一个成绩，如果成绩在80-100之间，则输出优秀；如果成绩在60-80之间，则输出中等；否则输出不及格，那怎么实现呢？
*/
/*
int score = 0;
printf("请输入一个成绩(0~100):");
scanf("%d",&score);
if (score >= 80 && score <= 100) {
printf("优秀");
} else if (score >= 60 && score < 80){
printf("中等");
} else {
printf("不及格");
}
*/
/*
从键盘输入一个字符，如果是数字打印 this is digital，如果是大写字母，打印 this is capital letter，如果是小写字母，打印 this is letter，如果是其他字符，打印 other。
*/
/*
char c = ‘0‘;
printf("请输入一个字符:");
scanf("%c",&c);
if (c >= ‘0‘ && c <= ‘9‘) {
printf("this is a digital");
} else if (c >= ‘a‘ && c <= ‘z‘) {
printf("this is letter");
} else if (c >= ‘A‘ && c <= ‘Z‘) {
printf("this is capital letter");
} else {
printf("other");
}
*/
/*
1、switch语句中switch后面只能写整型表达式、字符型表达式、整型变量、字符变量。
2、case语句中的break不要省略，否则会多个case语句一起执行，break的作用是跳出当前switch语句
3、case语句中如果要声明变量，必须加大括号
4、default中可以针对没有涉及到的情况，做处理
5、case后面的值只能是整型常量、整型常量表达式、字符常量、字符常量表达式
*/
/*
char c = ‘0‘;
printf("请输入一个字符(A~D):");
scanf("%c",&c);
switch (c) {
case ‘A‘:{
int a = 10;
printf("优秀");
break;
}
case ‘B‘:
printf("良好");
break;
case ‘C‘:
printf("及格");
break;
case ‘D‘:
printf("不及格");
break;
default:
printf("你有病啊？");
break;
}
int month, day = 0;
printf("请输入一个月份:");
scanf("%d",&month);
switch (month) {
case 1:
case 3:
case 5:
case 7:
case 8:
case 10:
case 12:
day = 31;
break;
case 4:
case 6:
case 9:
case 11:
day = 30;
break;
case 2:
day = 28;
break;
default:
break;
}
printf("day is %d",day);
*/
/*
1、枚举是一种构造数据类型，系统内部没有，人为创建的。定义枚举使用enum关键字
2、枚举值一定要将涉及到的所有情况罗列出来
3、枚举的作用是增强代码的可读性，方式是将人们能识别的标识符与计算机能识别的数字一一建立对应关系。
4、定义枚举变量的语法格式:enum 枚举名 变量名 ＝ 初值;不要忘了enum关键字，这是枚举的标志！
*/
//定义一个表示四季的枚举
enum season {
spring = 1,//1
summer,//2
autumn,//3
winter//4
};
enum season currentSeason = spring;
printf("请输入一个数字(1~4):");
scanf("%d",¤tSeason);
switch (currentSeason) {
case spring:
printf("Spring");
break;
case summer:
printf("Summer");
break;
case autumn:
printf("Autumn");
break;
case winter:
printf("Winter");
break;
default:
printf("你是企鹅吗?");
break;
}
return 0;
}
//第三节
//循环结构 就是在满足特定条件下，反复执行某程序段的结构。
//循环的主要作用是，减少重复代码的书写，让代码更加简洁。
/*
循环的四大内容:
1、循环变量初始化
2、循环条件
3、循环增量
4、循环体
*/
#pragma mark -----for循环-----
//for循环的语法格式
/*
for (循环变量初始化①; 循环条件②; 循环增量④) {
循环体③;
}
for循环的执行顺序为①②③④②③④②，当②不满足时，跳出循环。
for循环的循环次数为: (第一个不满足循环条件的数 - 循环变量初值) / 循环增量
*/
/*
for (int i = 1; i < 51; i ++) {
printf("第%d次吃包子 ",i);
}
*/
/*
for (int i = 1; i < 51; i += 5) {
printf("第%d次吃包子 ",(i + 4) / 5);
}
*/
//练习1，打印五遍hello lanou
/*
for (int i = 0; i < 5; i ++) {
printf("hello lanou");
}*/
//练习2，正序、倒序打印1～5
/*
for (int i = 1; i < 6; i ++) {
printf("%d ",i);
}
printf("\n");
for (int i = 5; i > 0; i --) {
printf("%d ",i);
}*/
//练习3 用for循环打印1-100之间的偶数。
/*
for (int i = 1; i < 101; i ++) {
if (0 == i % 2) {
printf("%d ",i);
}
}*/
//练习4 如何用for循环打印出200~300之间十位为7的数。
/*
for (int i = 200; i < 301; i ++) {
if (7 == i / 10 % 10) {
printf("%d ",i);
}
}*/
//练习5 如何用for循环打印出1~100之间既不是7的倍数并且也不包含7的数。
/*
for (int i = 1; i < 101; i ++) {
if (0 != i % 7 && 7 != i / 10 && 7 != i % 10) {
printf("%d ",i);
}
}*/
#pragma mark -----随机数-----
//随机数 函数为 arc4random()
//获取[a, b]范围内随机数的公式为 arc4random() % (b - a + 1) + a;
//练习6 用for打印20个随机数(范围为10~30)，求最大值和最小值
//声明变量来记录最大值、最小值
/*
int max = 0;
int min = 31;
int maxCount = 1;
int minCount = 1;
for (int i = 0; i < 20; i ++) {
int number = arc4random() % (30 - 10 + 1) + 10;
printf("%d ",number);
if (max < number) {
max = number;
maxCount = 1;
} else if (max == number){
maxCount ++;
}
if (min > number) {
min = number;
minCount = 1;
} else if (min == number) {
minCount ++;
}
}
printf("\nmax is %d, min is %d, maxCount is %d, minCount is %d\n",max, min, maxCount, minCount);*/
//控制台输入一个整数，判断这个数是不是质数？
//质数就是 除了1和本身之外，没有任何数能够整除。
/*
int number = 0;
printf("请输入一个整数:");
scanf("%d",&number);
//声明一个BOOL值，来记录该数是不是质数
BOOL isTrue = YES;//默认是质数
for (int i = 2; i < number; i ++) {
if (0 == number % i) {
isTrue = NO;
break;//一旦找到一个满足不是质数的条件，直接结束循环。
}
}
if (isTrue) {
printf("%d是质数",number);
} else {
printf("%d不是质数",number);
}
//计算1～100之间奇数的和，用continue来做。
int sum = 0;
for (int i = 1; i < 101; i ++) {
if (0 == i % 2) {
continue;
}
sum += i;
}
printf("sum is %d",sum);
*/
#pragma mark -----循环嵌套-----
//打印三行12345
// for (int i = 0; i < 3; i ++) {
// //打印数字
// for (int j = 1; j < 6; j ++) {
// printf("%d ",j);
// }
// printf("\n");
// }
/*
打印如下图形：
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
*/
// for (int i = 1; i < 6; i ++) {//外层循环控制打印行数
// for (int j = 1; j < i + 1; j ++) {
// printf("%d ",j);
// }
// printf("\n");
// }
/*
1 2 3 4 5
1 2 3 4
1 2 3
1 2
1
3 2 1
3 2
3
*/
/*
for (int i = 0; i < 3; i ++) {
for (int j = 3; j > i; j --) {
printf("%d ",j);
}
printf("\n");
}
for (int i = 0; i < 5; i ++) {
for (int j = 1; j < 6 - i; j ++) {
printf("%d ",j);
}
printf("\n");
}*/
//打印九九乘法表
/*
for (int i = 1; i < 10; i ++) {
for (int j = 1; j < i + 1; j ++) {
printf("%d×%d=%-2d ",j, i, i * j);
}
printf("\n");
}*/
#pragma mark -----while循环-----
/*
while循环的语法格式:
while (条件表达式) {
循环体;
}
当条件表达式为真时，执行循环语句，当条件表达式为假时，结束整个循环。
*/
/*
用while循环打印出1~100之间7的倍数。
用while循环打印出1~100之间个位为7的数。
用while循环打印出1~100之间十位为7的数。
用while循环打印出1~100之间既不是7的倍数并且也不包含7的数*/
//先声明一个循环变量
int i = 1;
while (i < 101) {
if (0 == i % 7) {
printf("%d ",i);
}
i ++;//循环增量
}
// while (1) {};
//输入一个整数，求这个整数的位数。
/*
long number = 0, count = 0;
printf("请输入一个数字:");
scanf("%ld",&number);
do {
number /= 10;
count ++;
} while (number != 0);
printf("count is %ld",count);*/
//for : 多用于明确循环次数的循环，而且是以后非常常用的循环结构，重点在于for循环的循环嵌套
//while : 多用于不明确循环次数的循环，知道循环结束的标志，先判断条件，再执行循环体。
//do...while : 多用于不明确循环次数的循环，知道循环结束的标志，先执行循环体，再判断循环条件，不管条件是否成立，循环体至少会被执行一次。
//在循环中有两个常用的关键字break、continue。
//break，结束本层循环，跳出离break最近的一层循环。腿断了。
//continue，结束本次循环，但是下一次循环还是会执行。如厕。
return 0;
}
//第四节
//宏命名的规则有两种:
//1、全部以大写字母命名，单词与单词之间以下划线隔开
#define ARR_COUNT 15
//2、k开头，后面的采用驼峰法命名
#define kArrCount 10
//宏只做替换，不做运算
#define MUL(A, B) ((A) + (B))
int main(int argc, const char * argv[]) {
int numberArray[ARR_COUNT] = {0};
int number = 5 * MUL(10, 20);
printf("number is %d\n",number);
//数组在C语言阶段是一种聚合变量，可以存放一组数据，不同于其他变量(标量)，我们也可以把数组认定为一种构造数据类型(系统内部没有给定的类型)。
//C语言阶段的聚合变量只有 数组 和 结构体，但是C语言阶段的构造类型除了 数组和结构体之外，还有我们之前学过的枚举。
//数组是一种保存 相同数据类型 元素的容器。
//定义一个数组的语法格式:类型修饰符(元素数据类型) 数组名[常量表达式(数组容量)] = {初值1, 初值2,...初值n};
//int 代表的是数组中每一个元素的数据类型
//ageArray是数组名，也是变量名
//数组的类型是int[5]，代表ageArray里面存放了五个整型元素
/*
int ageArray[5] = {22, 22, 21, 21, 18};
float scoreArray[5] = {50.0, 60.0, 70.0, 80.0, 90.0};
printf("%lu",sizeof(ageArray));
printf("\n%lu",sizeof(ageArray) / sizeof(int));*/
//访问数组元素的方式为:数组名 + [下标] 访问;
//数组元素下标从0开始，到数组容量 - 1
//切记 数组 不要越界访问。
// scoreArray[3] = 90.1;
// printf("\n%.2f",scoreArray[4]);
//数组和for循环通常都会一起出现，因为for循环的次数可以是数组容量，这样循环之后，我们可以获取数组中的所有元素，进行赋值或者取值。
// for (int i = 0; i < 5; i ++) {
// printf("%d ",ageArray[i]);
// }
/*
1、数组不能越界访问，下标越界，初值个数大于容量都会出现越界
2、数组下标从0开始，到容量 - 1
3、数组整体不能直接参与运算，不能直接赋值
*/
//如果初值的个数小于数组容量，空缺元素默认为0
int arr[5] = {1, 2, 3};
//数组可以不给定初值，默认全部为0，这是常用的数组定义方式
int arr1[5] = {0};
//数组定义时可以不给定容量，只给初值，系统通过初值个数确定数组容量
int arr2[] = {0};
//数组定义时，一定要确定数组容量！！！
/*
定义一个具有 20个元素 的 整型数组，每个元素的 取值范围是30-70之间，求 数组元素的和 以及 最大值，最大值的下标
复制一个数组，即两个数组 容量一样，把其中一个数组中的元素 复制 到另外一个数组中
定义 2个数组，每个数组都有 10个元素 ，元素取值范围 20-40之间，数组对应元素相加，放到另外一个数组中
*/
int array[20] = {0};
int sum = 0;//累加变量
int max = 0;//声明一个变量保存最大值
for (int i = 0; i < 20; i ++) {
array[i] = arc4random() % (70 - 30 + 1) + 30;
if (max < array[i]) {
max = array[i];
}
sum += array[i];
printf("%d ",array[i]);
}
printf("\nsum is %d, max is %d",sum, max);
for (int i = 0; i < 20; i ++) {
if (max == array[i]) {
printf("\n最大值下标为%d",i);
}
}
//冒泡排序的原理:比较无序数列相邻两个元素的大小，如果前面的大于后面的，交换两个元素，通过一趟趟的比较，形成一个有序数列。其中每一趟的比较，都可以得到这一趟比较的所有数中最大的那个数，放到序列的最后面。
/*
数组容量用count 表示，数组名为arr
for (int i = 0; i < count - 1; i ++) {
for (int j = 0; j < count - 1 - i; j++) {
if (arr[j] > arr[j + 1]) {
int temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
*/
for (int i = 0; i < 20 - 1; i ++) {//外层循环控制比较趟数
for (int j = 0; j < 20 - i - 1; j ++) {//内层循环控制比较次数
if (array[j] > array[j + 1]) {
int temp = array[j];
array[j] = array[j + 1];
array[j + 1] = temp;
}
}
}
printf("\n");
for (int i = 0; i < 20; i ++) {
printf("%d ",array[i]);
}
//字符数组
char name[] = {‘i‘, ‘P‘, ‘\\‘, ‘0‘, ‘o‘, ‘n‘, ‘e‘, ‘\0‘};
char aa[] = {‘i‘, ‘P‘, ‘n‘};
printf("aa length is %lu",strlen(aa));
printf("\nname length is %lu",strlen(name));
printf("\nname is %s",name);
printf("\n%lu",sizeof(name));
//字符串是以‘\0‘结尾的字符数组，‘\0‘也是一个字符，它是字符串的结尾标志，所以字符串所占空间要比字符数组占用大1
char phone[7] = "IPhone";
printf("\n%lu",sizeof(phone));
//字符串操作函数
//1、求字符串长度的函数 strlen()
//‘\0‘标志字符串结尾的字符，并不会计算在字符串长度范围之内
unsigned long length = strlen(phone);
printf("\nlength is %lu",length);
int i = 0;
while (phone[i ++] != ‘\0‘){}
printf("\n%d",i - 1);
//2、拷贝字符串的函数 strcpy()
char newPhone[7] = {0};
strcpy(newPhone, phone);
printf("\nnewPhone is %s",newPhone);
//3、字符串拼接 strcat()
char newName[255] = "i want an ";
strcat(newName, phone);
printf("\nnewName is %s",newName);
printf("\nnewName length is %lu",strlen(newName));
//4、字符串比较 strcmp()
//newName i want an iPhone
//phone IPhone
int result = strcmp(newName, phone);
printf("\nresult is %d",result);
/*
if (strcmp(arr[j], arr[j + 1]) > 0) {
char temp[255] = {0};
strcpy(temp, arr[j]);
strcpy(arr[j], arr[j + 1]);
strcpy(arr[j + 1], temp);
}
*/
//实现字符串倒转
char str[] = "sdfghjklm";
for (int i = 0; i < strlen(str) / 2; i ++) {
char temp = str[i];
str[i] = str[strlen(str) - 1 - i];
str[strlen(str) - 1 - i] = temp;
}
printf("\n%s",str);
return 0;
}
//第五节（函数）
#import <Foundation/Foundation.h>
#import "MyFunction.h"
#import "Operation.h"
void printArray(int arr[], int count) {
for (int i = 0; i < count; i ++) {
printf("%d ",arr[i]);
}
}
//函数定义的语法格式:
/*
返回值类型 函数名(参数列表) {
函数体;
}
*/
//函数如果从定义角度可以分为 库函数 自定义函数
//函数如果从返回值、参数有无来分，可以分为四类:
void exchangeNumber(int number1, int number2);
void exchangeNumber(int number1, int number2) {
int temp = number1;
number1 = number2;
number2 = temp;
}
/*
解决函数问题的书写步骤
1、command + N 创建一对新的文件。并且将.h .m中没有用的部分删掉
2、在.h文件中写函数的声明
3、在.m文件中写函数的定义
4、回到main.m文件之后，先通过#import""引入头文件，记住，引入的是.h文件，然后调用在.h文件中声明的函数，实现功能。
*/
int main(int argc, const char * argv[]) {
// int a = 10;
// int b = 8;
// exchangeNumber(a, b);
printf("%ld",factorial(5));
int year, month, day = 0;
printf("请输入年月日(中间以空格隔开):");
scanf("%d%d%d",&year, &month, &day);
int days = daysOfDate(year, month, day);
printNumber(days);
printHello();//不管函数定义时是否有参数，函数调用时，也就是使用函数时，代表参数的小括号绝对不能省略！！！
float pi = getPI();
printf("pi is %f\n",pi);
printNumber(10);
int x = 14, y = 8;
//函数调用时，形参会拷贝实参的值参与运算，改变形参的内容，并不会影响实参的内容，因为这是两块不同的内存空间。
int result = mo(x, y);
printf("result is %d\n",result);
// int a[5] = {0};
// int b[10] = {0};
// int c[20] = {0};
// for (int i = 0; i < 5; i ++) {
// printf("%d ",a[i]);
// }
/*
printArray(a, 5);
printArray(b, 10);
printArray(c, 20);
*/
// for (int i = 0; i < 10; i ++) {
// printf("%d ",b[i]);
// }
// for (int i = 0; i < 20; i ++) {
// printf("%d ",c[i]);
// }
return 0;
}
#import <Foundation/Foundation.h>
//加减乘除
int sum();
float sum1();
double sum2();
int sub(int a, int b);
int mul(int a, int b);
int mov(int a, int b);
int maxValue1(int a, int b);//两个数最大值
int maxValue2(int a, int b, int c);//三个数最大值
int maxValue3(int a, int b, int c, int d);//四个数最大值
//阶乘函数
long factorial(int n);
#import "Operation.h"
int sum(int a, int b) {
return a + b;
}
double sum2(double a, double b) {
return a + b;
}
int sub(int a, int b) {
return a - b;
}
int mul(int a, int b) {
return a * b;
}
int mov(int a, int b) {
return a / b;
}
int maxValue1(int a, int b) {
return a > b ? a : b;
}//两个数最大值
int maxValue2(int a, int b, int c) {
int max = maxValue1(a, b);
max = maxValue1(max, c);
return max;
}//三个数最大值
int maxValue3(int a, int b, int c, int d) {
int max = maxValue2(a, b, c);
max = maxValue1(max, d);
return max;
}//四个数最大值
long factorial(int n) {
if (1 == n) {
return 1;
}
return n * factorial(n - 1);
}
//1、无参无返回值
void printHello();
//2、无参有返回值
float getPI();
//3、有参无返回值
void printNumber(int number);
//4、有参有返回值
int mo(int a, int b);
//计算 1到n的和
int sumOfNumber(int n);
//给定一个日期，计算 这个 日期是当年的第几天
int daysOfDate(int year, int month, int day);
//求三个数中间值
int getMiddleNumber(int a, int b, int c);
//计算一个整数的位数
int sumOfDigit(int number);
#import "MyFunction.h"
void printHello() {
printf("hello world\n");
//如果函数没有返回值，return有两种写法
//1、不写return
//2、return ;
//常用第一种，直接省略return
}
float getPI() {
return 3.141592;
}
void printNumber(int number) {
printf("%d\n",number);
}
int mo(int a, int b) {
// printHello();
a = a + 1;
b = b + 1;
return a % b;
}
int sumOfNumber(int n) {
int sum = 0;
for (int i = 1; i < n + 1; i ++) {
sum += i;
}
return sum;
}
int daysOfDate(int year, int month, int day) {
int months[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
if (0 == year % 400 || (0 == year % 4 && 0 != year % 100)) {
months[1] = 29;
}
int days = 0;
for (int i = 0; i < month - 1; i ++) {
days += months[i];
}
days += day;
return days;
}
int getMiddleNumber(int a, int b, int c) {
int number[3] = {a, b, c};
for (int i = 0; i < 3 - 1; i ++) {
for (int j = 0; j < 3 - 1 - i; j ++) {
if (number[j] > number[j + 1]) {
int temp = number[j];
number[j] = number[j + 1];
number[j + 1] = temp;
}
}
}
return number[1];
}
int sumOfDigit(int number) {
int count = 0;
while (number) {
number /= 10;
count ++;
}
return count;
}
到函数时自己是听不懂的，现在看来好多了，只是还有好多知识点要进行重新学习，对于c语言还要进行多练。
原文：http://www.cnblogs.com/wwww543623/p/5169995.html