C语言入门
目录
C语言中最基本的是掌握一些输入输出，了解scanf,printf两个的基本用法
C语言中最基本的是掌握一些输入输出，了解scanf,printf两个的基本用法
#include<stdio.h>
#include<string.h>
int main()
{
int get_max(int x,int y);
int num1,num2;
scanf("%d%d",&num1,&num2);
int max=get_max(num1,num2);
printf("max=%d\n",max);
return 0;
}
int get_max(int x,int y)
{
if(x>y)
return x;
else
return y;
}
int main()
{
char arr [] = "hello";//字符数组
char arr1 []="abc";
char arr2 []={'a','b','c'};//多个字符用大括号
printf("%s\n",arr1);//%s打印字符串或多个字符 %c打印字符 printf("%c",'a');
printf("%s\n",arr2);
// int len=string length ("abc");
// printf("%d\n",len);
//printf("%d",100);打印整形
//8进制130 = 8^2*1+8^1*3+8^0*0 65=8进制 101 =8^2*1+8^1*0+8^0*0 8进制无81.上面的代码其实还包含着函数声明与定义，函数声明的时候不需要写函数体，但是定义的时候要写。
2.牵涉一些进制问题 ddd ddd表示1~3个八进制 的数字 eg:130 076
xdd dd表示2个十六进制数字 eg:0x30
3. C++控制符 /操纵符: cout输出时进行格式上的控制
setprecision(4)总共有效 例如：12.345=12.34 用时要加头文件#include<iomanip>
cout<<fixed<<setprecision(2)<<a<<endl;//只保留 a小数点后的位数
cout<<scientific<<a<<endl;
4.优先级
关系运算 的结果一定是真或假
bool true 1 false 0
> >= < <= (优先级高) ==(判断相不相等) != (优先级低)
a==(b<c)
优先级： 算术运算>关系运算>赋值运算
逻辑运算 真1 假0 &&与 ||或 !非
bool flag1,flag2=true;//bool int char 三者相通
flag1=flag2;
cout<<flag1;
return 0;
优先级：!>算术运算>关系运算>&&、||> 赋值运算5.常量标识：const float pi=3.141592653，或者#define PI 3.141592653
6.原码 反码 与 补码 ：原码 最高位为符号位 反码 符号位不变 其他位 0变1 计算机识别的是补码 反码+1=补码
数组 与 字符串
1.整个数组作为函数参数， 相当于传递了首元素的地址， 可以实现数组元素的双向传递
int arr[10]={1,2,3,4,5,6,7,8,9,10}; 数组：一组相同类型的元素集合；
2.形参是完整的数组形式：void xuanze(int a[][6],int n)
实参只需要数组名就可以，xuanze(a,4)//4为省略的列
数组名作为函数实参时，如果改变形参数组元素的值，能同步改变实参的数组元素值
char c[]={'a','b','c'}; //初始化 单引号
c[1]='d';
for(int i = 0; i < 3;i++)
cout<<c[i]<<' ';
char name[]="wang keming";//用字符串初始化字符数组
//字符串的结束标志 \0， 'a'+'\0' ="a";
//对于字符数组可以用数组名直接输出3.string 的相关用法 用getline(cin,a);输入（可以包含空格输出，以回车结束）
注意这里没有引入对fgets等C语言的用法，因为现在主要学的是C++
strcat 连接函数
strcat(str1,str2);
char str1[]="Hello";
char str2[] ="everyone";
cout<<strcat(str1,str2);
//复制函数
cout<<strcpy(str1,"wangkeming");
cout<<str1;
//strcmp 比较函数 asc ii值 相等 0 大于 正数 小于负数
//strlen 长度函数
cout<<strlen(str1); #include<iostream>
#include<string.h>
using namespace std;
int main()
{
char a[100] = "HELLO WORLD !";
for(int i = 0; i< strlen(a); i++)//两重循环
cout<<a[i];
for(int i = 0,len = strlen(a);i<len;i++)//节省时间
cout<<a[i];
char b[100];
cout<<strlen(b);
return 0;
}int main(){
int arr[10]={0};
printf("%d\n",sizeof(arr));//计算的是数组总大小，单位字节
printf("%d\n",sizeof(arr[0]));
int x=sizeof(arr) / sizeof(arr[0]);
printf("%d",x);
return 0;
}循环结构
1.for循环
for 循环的格式为：for（初始化；条件；调整）循环体；for循环执行的时候先执行第一句初始化，然后判断条件，如果成立，执行循环体，然后完成调整后再判断条件，如果成立，再执行循环体........知道条件不成立为止。
2.while循环
while循环的格式为：“while(条件) 循环体；”
3.do-while循环
do-while 循环的格式为“do{ 循环体 } while(条件)；” 其中循环体至少执行一次，每次执行完循环体后判断条件，当条件满足时继续循环。
4.while 语句 break用于永久的终止循环，continue的作用是跳过本次循环后面的代码，直接去判断部分，看是否执行下一次循环
下面上代码：（就拿近期实验报告内容为参考）
// 编写程序，分别使用do{…} while(); while(){…}; for(){…}三种循环语句，计算1+2+…+99+100的和。
#include<iostream>
using namespace std;
int main()
{
int i=1,sum=0;//求和sum初始化为0
do
{
sum+=i;
i++;
}
while(i<=100);
cout<<"sum1= "<<sum<<endl;
i=1; sum=0;
while(i<=100)
{
sum+=i;
i++;//避免死循环
}
cout<<"sum2= "<<sum<<endl;
i=1; sum=0;
for(; i<=100; i++)
{
sum+=i;
}
cout<<"sm3= "<<sum;
return 0;
}
5. 循环的嵌套
例如：外层i<=100 内层j<=10 总共循环1000次 每次先搞定内循环
函数和递归
1.函数功能：减少编程的重复，一次定义函数 ，多次调用
主函数：调用各个函数
函数要素：1函数类型 2 函数名 3 参数 {4 函数体}
函数类型 ：int char float （ 非void类型） 函数结果的类型就是函数类型 当return 的类型和函数类型不一致时，会强制转换
void 空类型 对于 void 类型函数 可以有return; 他的作用只是直接结束函数 （ break 的作用是结束循环体 ）
对于其他有return 的如果(eg:int )最后没有return ，就会最后随机给一个数。
2.函数的嵌套调用：自己调用别人
函数的递归： 自己调用自己 n!=n*(n-1)!
int fac(int n)
{
if(n==0 || n==1)
return 1;
else
return n*fac(n-1);
}3. 内联函数 inline 函数 内置函数 （空间换时间）
对于简单的，但重复使用的函数
对于有循环，switch,有复杂if语句 不适合
内联是用户的一种请求，但请求批不批准，编译器自己决定
4.重载函数（ C++独有的）
函数名一样 类型类型||参数个数||参数顺序||不一样 功能类似
5.函数模板
//函数模板 把具体的类型泛化成一个T
//编译器的行为：把模板进行实例化，将T 替换成统一的类型
template <typename T>
T add(T a,T b)
{
return a+b;
}
template <typename T1,typename T2>
T add(T1 a,T2 b)
{
return a+b;
}
int main()
{
int x=1, y=2;
cout<<add(x,y)<<endl;
}
//带默认参数的函数：带默认形参值的函数
//如果没有给实参，则按默认值进行计算
//如果给了实参，则以实参为准
//默认形参一定从右往左依次给
//实参是从左往右 6.变量及作用域
/* 局部变量:函数内部定义的变量,函数的形参,复合语句内定义的
离开了它所在的块,它就消亡了,只能在定义的下面访问,内存仍然有
全局变量：不在函数内部 作用 增加数据的联系渠道
同名隐藏：前提是一定有嵌套，内层创建的变量会隐藏外层创建的变量
作用域：变量的有效范围
文件作用域：全局
函数作用域：函数内部定义的，包括形参
块作用域：复合语句
函数原型作用域： 原型里的形参，最小的作用域
变量的存储类别
静态存储区：一旦创建，程序结束才消亡
全局变量 或 static + 局部变量 仍然是局部变量只能局部调用
//动态存储区 ：离开所在的块，就自动消亡
//普通的局部变量
//存储类别：自动变量（默认），static,register,extern(外部声明，针对全局变量)
CPU 直接计算寄存器 */
1. #include<iostream>
using namespace std;
int main()
{
extern int f;
f;
}
int f;
2.//或者项目两个文件 但只能有一个main函数
static int f=11;//这个f只在本文件中使用
//外部函数(默认的所有函数) 使用的时候原型写一遍
//内部函数 多个文件一样的函数 前加 static
//头文件
file.h 不编译
file.cpp 和 main.cpp 编译
最好在file.cpp中包含#include"file.h"//用于自己写的头文件 编译器自己检查 7.关键字
sign 有符号的 10 -20
unsign 无符号的
static 静态的！
union 联合体（共用体）
void 无-空
此外 define include 为预处理指令 非关键字
int main()
{
大量/频繁被使用的数据，想放在寄存器中，提升效率
register int num=100;建议num的值存放在寄存器中
typedef 类型重命名
typedef unsigned int u_int;
int main()
{
unsigned int num=100;==u_int num2=100;
return 0;
}
关键字static 静态的
1：static修饰局部变量
2：static修饰全局变量
3： static修饰函数
void test()
{
static int a=1;//打印2到11，没有static打印10个2
a++;
printf("%d ",a);
}
static 修饰局部变量，改变了局部变量的生命周期（本质上是改变了变量的存储类型）
static修饰全局变量/函数，使得这个全局变量/函数只能在自己所在的源文件内部可以使用，其他源文件不能使用！
全局变量，在其他源文件内部可以被使用，是因为全局变量具有外部链接属性
但是被static修饰之后，就变成了内部链接属性！ 其他一些小细节
1.除法计算 整形除以整形 会向下取整
int main()
{
//float a=9/2;
float a=9/2.0; //除号两端有一个是小数执行的是小数除法
printf("%f\n",a);
return 0;
}2. 位操作符
#include<stdio.h>
int main(){
int a=2; // 整形4个字节 1个字节8个比特位
int b=a<<1; //左移操作符 移动的是二进制位
printf("%d",b);// b=4
// 二进制：00000000000000000000000000000010 100=2^2*1+0+0
return 0;
} 3.强制类型转换
int main()
{ int a=(int)3.14;//强制类型转换
printf("%d",a);
return 0;
}4.逗号表达式
int main()
{
int a=0;
int b=3;
int c=5;
int d=(a=b+2,c=a-4,b=c+2);//逗号表达式，是从左往右依次计算的，最后结果是最后一个表达式的结果
printf("%d",d) ;
return 0;
}5.在函数内，局部变量的值会覆盖全局变量的值
6.++的使用
int main()
{
int a=10;
int b=a++;//后置++，先使用，再++
printf("%d",b);//10
printf("%d\n",a);//11
int b= ++a;//前置++，先++，后使用
//printf("%d",b);//11
// printf("%d",a)//11
}
以上就是部分的基础东西，以后还会更新除基础外的一些算法内容，包括计算机方面的知识，以便大家复习！
1360
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
