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进制无8
1.上面的代码其实还包含着函数声明与定义,函数声明的时候不需要写函数体,但是定义的时候要写。
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
}
以上就是部分的基础东西,以后还会更新除基础外的一些算法内容,包括计算机方面的知识,以便大家复习!