持续更新ing~
变量,运算符,条件选择,循环,数组,函数篇
#include <iostream>
using namespace std;
#define day 7
int main()
{
// cout<<"hello world!"<<endl;
int a=10;
cout<<day<<endl;
const int month =12;
// month=24;//报错,const修饰也是常量,不可修改
//1.5 关键字,不可以关键字为变量命名
/*1.6标识符
标识符不能是关键字
标识符只能以数字,下划线,字母组成
标识符第一个字母只能是字母或吓坏谢娜
标识符区分大小写字母
(起名最好是见名知意)
*/
//数据类型
/*注意赋值不能超过各个类型最大范围,例如int:-32768~32767
sizeof 求出数据类型占用内存大小
sizeof (数据结构/变量)
short<int<=long<=long long
浮点型
定精度 float 4字节 (7位有效数字)
双精度 double 8字节(15-16位有效数字)
float f1=3.14f;//(加f可以少让程序做一个转换,明显告诉这是单精度)
默认情况下,输出一个小数,会显示6位有效数字
科学计数法
float f2=3e2;//3*10^2
float f3=3e-2;//3*0.1^2
字符型
char ch='a';//所占内存空间1个字符
cout<<sizeof(ch)<<endl;
cout<<(int)ch<<endl;
转义字符
\' 单引号
\"双引号
\?代表问号
\n 换行
\\ 输出\
\t 水平制表符 8个空格,有对齐效果
字符串
头文件
#include <string>
char str1[]="hello world!";
string str2="hello world!";
布尔类型
bool flag=true/false(1/0)
占用1个字节
数据的输入
cin>>变量
///
运算符
算术运算符
两个小数可以相除,结果也可以是小数
两个整数相除,结果仍然是整数
% 取模/取余,除数也不能为0
两个小数不能做取模运算
递增递减运算符
前置,后置
前置递增,先让变量+1,然后进行表达式运算
后置递增,先进行表达式运算,后+1
a=2;b=++a;a=3,b=3
a=2;b=a++; a=3,b=2
a=2;b=--a;a=1,b=1
a=2;b=a--; a=1,b=2
赋值运算符
=,+=,-=,*=,/=,%=
比较运算符
==.!=,>,<>=,<=,返回值是0或1,真为1,假为0
逻辑运算符
!.&&,||
cout<<(a&&b)<<endl;//小括号优先级运算,先做与运算
///
程序流程结构
顺序结构,选择结构,循环结构
if else
三目运算符
表达式1?表达式2:表达式3 (如果表达式1为真,执行表达式2,并输出表达式2结果,为假则执行表达式3,输出表达式3结果)
swich语句
switch ()
{
case 结果1:执行语句;break;
case 结果2:执行语句;break;
...
default:执行语句;break;
}
if与switch区别?
//swich 缺点,判断时候只能是整型或者字符型,不可以是一个区间
switch 优点.结构清晰,执行效率高
///
循环结构
生成随机数,,添加随机数种子,利用当前系统时间生成随机数,避免每次随机数都一样
strand ((unsigned) time (NULL)) //要加头文件 #include <ctime>
系统生成随机数
int num=rand()%100+1//生成0+1~99+1随机数
do while 先执行一次循环语句,再判断循环条件
num=0;
do
{
cout<<num++<<endl;
}while (num<10)
for 循环语句
for(起始表达式;循环条件;末尾循环体){循环表达式;}
跳转语句
continue:跳出本次循环
break,跳出一个选择语句,出现在switch中,或跳出一个循环语句
goto,无条件的跳转语句
语法:goto 标记,功能强大,不经常使用,因为跳来跳去,不便于阅读代码,结构不好
goto FLAG;
FLAG:
/数组
特点1: 数组中每个数据元素都是相同类型的数据
特点2: 数组是由连续的内存位置组成
int arr1[5];
arr1[0]=10;
...
arr1[4]=50;
int arr1[5]={1,2,3,4,5};
int arr3[]={1,2,3,4,5,6,7,8,9};//定义数组的时候,必须有出初始长度;
数组名的用途:
1.统计整个数组在内存中的长度; sizeof(arr1)
2.可以获取数组在内存中的首地址; cout arr1 ,cout (int)arr1(转10进制)
数组中第一个元素地址: (int)&arr[0];
数组名是一个常量,不能进行赋值操作;,其含义为数字首地址
int start=0 起始元素下标
int end =sizeof(arr)/sizeof(arr[0])-1;
冒泡排序
作用:
1.比较相邻元素,如果第一个比第二个大,就交换
2.对每一对相邻的元素做同样的工作,执行完毕后,找到第一个最大值
3.重复以上步骤,每次比较次数-1,直到不需要比较
for (int i=0;i<N-1;i++) //排序轮数
for(int j=0;j<N-i-1;j++) //内存循环比较
二位数组
int arr [2][3]
int arr1[2][3]={{1,2,3},
{4,5,6}};
int arr2[2][3]={1,2,3,4,5,6,};
int arr3 [][3]={1,2,3,4,5,6};
二位数组名
查看二位数组所占用空间
查看二维数组首地址
sizeof(arr) //二维数组占用内存空间
sizeof(arr[0]) //二位数组第一行占用内存空间
sizeof(arr[0][0])
二位数组首地址 (int)arr
二维数组第一行首地址(int)arr[0]
二维数组第二行首地址(int)arr[1]
///
函数
int add(int num1,int num2)
{
int sum =num1+num2;
return sum;
}
值传递,函数调用时,实参将数据传给形参
形参发生改变,不会影响实参数
函数常见样式
1.无参无返
void test01()
{
cout <<"this is test01"<<endl;
}
2.有参无返
void test2(int a)
{
cout <<"this is test2 a="<<a<<endl;
}
3.有参无返
int test3()
{
cout<<"this is test3"
return 1000;
}
4.有参有返
into test4 (int a)
{
cout<<"this is testa="<<a<<endl;
return 0;
}
函数的声明:告诉编译器函数的名字及如何调用函数
eg: int max(int a,int b);
声明可以写多次,定义只能写一次
函数的分文件编写:让代码结构更加清晰
步骤:
1.创建后缀名为.h的头文件
2.创建.cpp的源文件
3.在头文件写函数的声明
#include <iostream>
using namespace std;
4.在源文件写函数的定义
#include "swap.h"
定义
main 函数
#include <iostream>
using namespace std;
#include "swap.h
*/
system("pause");//按任意键继续
return 0;
}
指针
//指针
//可以通过指针来保存一个地址
int *p;
p=&a;
// 通过使用指针,解引用*,制找到指针指向的那个内存,可进行修改
*p=1000;
a=1000;*p=1000;
//指针所占用的内存空间,32位操作系统占用4位字节,64位操作系统占用8位字节,无论是什么数据类型,例如int,double,char
//空指针:指针向量指向内存中编号为0的空间,用途:初始化指针,空指针指向的内存是不可访问的
int *p=NULL;
*p=100; //可以修改指向,不能直接访问,0~255是系统占用,不允许用户访问
//野指针,指向非法的内存空间
int *p=(int*)0x1100;
cout<<*p<<endl; //报错,访问权限冲突,程序中避免出现野指针
//空指针和野指针都不是自己申请的空间,因此不要访问
//const 修饰指针
/*
1.const 修饰指针 -----常量指针,特点:指针的指向可以修改,但是指针指向的值不能修改 const int *p=&a *p=20错误,p=&b,正确
2.const 修饰常量-------指针常量,特点:指针的指向不可以修改,但指针指向的值可以修改 int *const p,*p=&a *p=20正确,p=&b,错误
3.const 既修饰常量又修饰指针,特点: 指针的指向,指针指向的值都不可以修改,const int * const p=&a,*p=&a *p=20错误,p=&b,错误
*/
//指针和数组,利用指针来访问数组中元素
int arr[10]={1,2,3,4,5,6,7,8,9};
int *p=arr;
*p=1;
p++;//p四个字节
*p=2;
//指针和函数
//地址传递,形参修改实参
结构体
//属于用户自定义的数据类型,允许用户存储不同的数据类型
//语法 strcut 类型名称 {成员列表}
/*定义
struct 结构体名 变量名
struct 结构体名 变量名={成员1值,成员2值,...}
定义结构体时顺便创建变量
*/
struct Student
{
/* data */
string name;
int age;
int score;
};
struct Student s1; //struct 关键字可以省略
s1.name="张三";
s1.age=18;
s1.score=100;
struct Student s2={"李四",19,80}; //struct 关键字可以省略
struct Student
{
/* data */
string name;
int age;
int score;
}s3;
s1.name="王五";
s1.age=20;
s1.score=37;
//结构体数组
struct Student stuArray[3]={
{"张三",18,100};
{"李四",28,99};
{"王五",39,98};
};
//结构体指针
struct Student stu={"张三",18,100};
Student *p=&stu;//类型要匹配
cout<<"姓名:"<<p->name<<"年龄"<<p->age<<"分数"<<p->score<<endl; //指针通过 ->可以访问成员
//结构体嵌套结构体
struct teacher
{
/* data */
int id;
string name;
int age;
struct Student stu;
};
teacher t;
t.id=100000;
t.name="老王";
t.age=45;
t.stu.name="小王";
t.stu.age=18;
t.stu.score=80;
//结构体做函数参数,传递方式两种:1.值传递,地址传递
void printfStudent(struct Student s)
{
cout<<"姓名:"<<s.name<<"年龄"<<s.age<<"分数"<<s.score<<endl;
}
//地址传递
void printfStudent1(struct Student *p)
{
cout<<"姓名:"<<p->name<<"年龄"<<p->age<<"分数"<<p->score<<endl;
}
//结构体中const 防止修改,误操作
void printfStudent1(const struct Student *p)
{
//p->age=100;//报错,禁止修改
cout<<"姓名:"<<p->name<<"年龄"<<p->age<<"分数"<<p->score<<endl;
}
string name ="teacher";//字符串xiangjia
name +='a';
system("pause");//按任意键继续
return 0;
}
内存分区模型
/程序的内存模型
//代码区:存放函数体的二进制代码,由操作系统进行管理
/全局区,存放全局变量,静态变量以及常量
/栈区:编译器自动分配释放,存放函数参数值,局部变量等
/堆区:由程序员分配释放,若程序员不释放,程序结束后由操作系统回收
不同区域存放不同变量,赋予不同的生命周期,有更灵活的编程
全局变量
常量存放地址距离全局变量,静态变量很近,但是距离局变量较远
总结
代码运行后
栈区数据注意事项
不要返回局部变量地址
void *func(int b)
{
int b=100; //形参也会放在栈区
int a=10; //局部变量,存放在栈区,栈区数据在函数执行完后自动释放
return &a;//返回局部变量地址
}
int main ()
{
int *p=func(1);
cout <<*p<<endl;//10.第一次编辑器做了保留
cout <<*p<<endl;//乱码.第二次,数据不在保留
system ("pause";)
}
堆区
///堆区,在堆区开辟数据,
void *func()
{
//利用new关键字 可以将数据开辟到堆区
int *p=new int(10); ///指针本质也是局部变量,放在栈上,指针保存的数放在堆区
return p;
}
int main ()
{
int *p=func();
cout <<*p<<endl;//10
cout <<*p<<endl;//10
cout <<*p<<endl;//10
cout <<*p<<endl;//10
system ("pause";)
}
new操作符
///new 操作符
int *func()
{
//在堆区创建整型数据
//new返回是 该数据类型的指针
int *p=new int(10);
}
int main ()
{
int *p=func();
cout <<*p<<endl;//10
cout <<*p<<endl;//10
cout <<*p<<endl;//10
//堆区数据由程序员管理开辟和释放,如果想释放,利用关键字delete
delete p;
cout <<*p<<endl;//内存已经被释放,再次访问就是非法操作,就报错
system ("pause";)
}
在堆区利用new开辟数组
void test2()
{
//创建10整型数据的数组,在堆区
int *arr=new int[10];//10代表数组有10个元素
for (int i=0;i<10;i++)
{
arr[i]=i+100;
}
for (int i=0;i<10;i++)
{
cout<<arr[i]<<endl
}
//释放堆区数组,要加一个 []才可以,否则只释放一个数据
delete [] arr;
}
C++中的引用
总结:通过引用参数和地址传递效果是一样的,引用语法更简单
引用做函数返回值
不要返回局部变量的引用
//如果函数返回值是引用,这个函数值可以作为左值,来进行赋值.
引用的本质
引用的本质在c++内部实现是一个指针常量
总结:c+=推荐 引用技术,因为操作方便,引用本质是c++指针常量,里面的指针操作,编译器直接完成.
881
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
