C语言学习笔记

1. 字面常量: 直观写出来的值
2. const修饰发常量
3. #define定义的常量
4. 枚举常量

int main()
{
    const int num = 1;\const 表示常属性变量的创建
    num = 8;
    return 0;
}
​

是不能运行的

int main()
{
    const int n = 4;
    printf("%dn", n);
    int arr[n] = { 0 };
    return 0;
}
​
int main()
{
    const const int n = 4;
    printf("%dn", n);
    int arr[n] = { 0 };
    return 0;
}

都不能运行, const int n表示n是一个具有常属性的变量,不是常量.

#define _CRT_SECURE_NO_WARNINGS 1
#include
#define MAX 10
int main()
{
    int arr[MAX] = { 0 };
    return 0;
}

这个可以运行,因为#define定义了一个标准常量

enum Sex\枚举常量
{
    MALE,
    FEMALE,
    SECRET
};//枚举常量的可能取值, 大括号内给定的枚举常量是不能改变的, 枚举变量是可以改变的
int main()
{
    printf("%d",MALE);//0
    printf("%d",FEMALE);//1
    printf("%d",SECRET);//2
}

多个字符放在双引号内就是字符串 "hello bitn"

int main()
{
"abcdef";//字符串
"";//空字符串
return 0;
}

#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
    char arr1[] = "abc";
    //"abc"--'a','b','c','' =>''表示字符串的结束标志,''的值是0
    //char arr2[] = { 'a','b','c' };'c'的后面应该加上一个0
    char arr2[]={'a','b','c',0};
    printf("%sn", arr1);
    printf("%sn", arr2);
    printf("%dn", strlen(arr1));
    printf("%dn", strlen(arr2));//打印字符串长度,3
    return 0;
}

数据在计算机上存储的是二进制,字符是以ASCII编码储存.

 n把本义变了,使某一个字符不再是原来的意思,表示换行

#define _CRT_SECURE_NO_WARNINGS 1
#include
int main()
{
    printf("abcn");
    return 0;
}

t叫水平制表符,类似Tab键

c的注释 c++的注释//` 都可以用 注释用于代码难懂的地方

#include
int main()
{
    float f=3.1415926;
    printf("%2.3fn",f);
    printf("%fn",f);
    return 0;
}

其中%2.3f2表示格式(被超过了就忽略), 3表示保留小数点位数(四舍五入)

putchar()

scanf() 如果需要提示语句, 单独写一行printf, 不能写在scanf中

即输入一个整型值后紧接着按回车输入另一个字符, 会将回车变成输入. 清除的方法有

1. 用getchar()吃掉
1. %[空格]c或%*c

1. gets(s)
2. scanf()会将空格作为字符串输入的结束标志(处理连续字符输入时可以处理空格)

puts

会自动换行

加 减 乘 除(/) 取余(%) 取余不能给浮点数进行.

>``>=``<=``<

==``!=

1. !取反: 1变 0,0变1
2. ||或

针对二进制的位(0/1)

位运算可以以任何数据类型

z=(x+=5,y=x+0.2)

z的值由最后一个表达式决定

建议多加括号解决优先级问题

#include
int main()
{
	int x = 1, y = 0, z = 0;
	x += y == z,y = x + 2, z = x + y + x > 0;
	printf("%d,%d,%dn", x, y, z);
	return 0;
}

解引用运算符*的优先级要小于下标运算符[], 因此表示数组指针需要加括号例如int (*p)[10]

C语言中不会对数组做越界判断, 需要自己限制

1. 数组如果不初始化, 值是随机的.
2. static数组元素不赋值, 默认是0
3. 只给部分赋值, 后面默认0
4. 初始化给多了直接报错

#include
int main(int argc, char const *argv[])
{
	int a[7]={49,38,97,76,13,27,30};
		int i = 0,j=6,temp;
	for (;j>=0;j--)
	{
		for(i=0;i<=j;i++)
			{
				if(a[i]>a[i+1])
				{
					temp = a[i];
					a[i] = a[i+1];
					a[i+1] = temp;
				}
			}
			
	}
	for(i=0;i<=6;i++)
		{
			printf("%dn",a[i]);
		}

	return 0;
}

P[行][列]

定义方式: 行数可以省略, 列数不可以

二维数组存储的验证

#include
int main(int argc, char const *argv[])
{
	int a[4][5]={{1,2,3,4,5},{6,7,8,9,10},{11,12,13,14,15},{16,17,18,19,20}};
	for(int x = 0; x < 4; x++)
	{
		for(int y = 0; y < 5; y++)
		{
			printf("The id of a[%d][%d] is %pn",x,y,&a[x][y] );
		}
	}
	return 0;
}

#include

int main(int argc, char const *argv[])
{
	int a[10][10];
	for(int x = 0; x < 10; x++)
		{
			for(int y = 0; y < 10; y++)
			{
				if(y == 0 ||x == y)
					a[x][y]=1;

			}
		}
	for(int x = 2; x < 10; x++)
	{
		for(int y = 1; y < x; y++)
		{
			a[x][y]=a[x-1][y-1]+a[x-1][y];
		}

	}
	for(int x = 0; x < 10; x++)
	{
		for(int y = 0; y <= x; y++)
		{
			printf("%d ",a[x][y]);
		}
		printf("n");
	}
	return 0;
}

C语言中, 字符串依附于字符数组存在

1. 逐个元素赋值
2. 字符串赋值 "abc" ->a, b, c,
   0 NULL都是一回事, ASCII码值是0

, '0'是另一回事, ASCII码值是48

#include
int main()
{
	char fruit[][20] = { "bannana","apple","strawmerry","watermelen" };
	int i, j, n, m;
	n = sizeof(fruit) / sizeof(fruit[0]);
	m = sizeof(fruit[0]) / sizeof(fruit[0][0]);

	for (i = 0; i < n; i++)
	{
		for (j = 0; j < m; j++)
		{
			putchar(fruit[i][j]);
		}
		putchar('n');
	}
	return 0;
}

sizeof()得到的是总空间, 包括未赋值部分, strlen得到的是实际的字符串长度(需要string.h>)

char s[10] = { 'A', 0, 'b', '', '0' };
printf("%zd", strlen(s));//这将返回1, 因为遇到0, 就认为字符串结束了
printf("%d", sizeof(s)/sizeof(char));//这将返回10, 表示整个数组

char s[20] = "ttnasdczx0qwe";
printf("%zdn", strlen(s));//返回10  t,n分别被视为一个字符
printf("%d", sizeof(s)/sizeof(char));//返回20
char s[20] = "x69141n"; // xhh表示十六进制数代表的符号, ddd表示八进制数代表的符号 一般不建议这样写
printf("%zdn", strlen(s));

#include

#include
int main(int argc, char const* argv[])
{
	char s1[]="123aeqw$asdsa";
	int ch;

	ch='$';

	printf("%p,%p,nn",s1,strchr(s1,ch));	
	return 0;
}

#include
#include
int main(int argc, char const* argv[])
{
	char s1[]="how are you";
	char s2[]="are";
	printf("%ldn",strstr(s1,s2)-s1);
	return 0;
}

int a[3][2]={{1,6},{9,12},{61,12}};
int *p,i,n;

n=sizeof(a)/sizeof(int);
p=a;//warning

p=a[0]

char *p="hello world";

double *pa[2], a[2][3]

 void * [指针名] 

l一般形式如下:

<数据类型> <函数名称>( <形式参数说明> ) {

​      语句序列；

​      return[(<表达式>)];

} 

double p(int x);

char *str = "hello"

#include
int calcu(int x);
int main()
{
	printf("%dn",calcu(10));
	return 0;
}
int calcu(int x)
{
	if (x==0)
	{
		return 1;
	}
	double factorial = x;
	factorial*=calcu(x-1);
	return factorial;
}

int main()
{
	for(int num = 1; num <= 10; num++)
	{
		printf("%dn",fib(num));
	}
	return 0;
}
int fib(int x)
{
	int fibx;
	if (x == 1 || x == 2)
	{
		return 1;
	}
	fibx = fib(x-1)+fib(x-2);
	return fibx;
}

#include
int add(int, int);

int main()
{
	int m = 10,n = 20;
	int (*p)(int ,int );
	p=add;
	printf("%dn",p(m,n));
	return 0;
}
int add(int x,int y)
{
	return x+y;
}

#include
#include
int stol(const void *x, const void *y);

int main()
{
	int a[10] = {5.7,3,6,4,2,8,9,1};
	qsort(a,sizeof(a)/sizeof(int),sizeof(int),stol);
	for(int k = 0; k<= 9; k++)
	{
		printf("%dn",a[k] );
	}
	return 0;
}
int stol(const void *x, const void *y)
{
	return *(int *)x - *(int *)y;
}