C++第一阶段基础知识

一、头文件及一些简单知识

#include<iostream>

cout<<””<<end1;   ==   cout<<”\n”;换行

cout<<”a=”<<a<<end1;      (a=a;)

system(“pause“)；

定义常量：

1、#define宏常量：#define 常量名 常量值

（文件上方定义，下方不可修改）

例如：#define day 7

2、const修饰的变量：const 数据类型=常量值

（const int Day=7不可修改）

二、数据类型

1、整形

数据类型：

1）short（短整型2字节-2^15~2^15-1）

2）int(整形4字节-2^31~2^31-1)

3）long(长整型-2^31~2^31-1windows4字节，linux为4字节32位，8字节64位)

4）long long（长长整形8字节-2^63~2663-1）

注意：当定义的数值超过本身范围时，输出值为范围下限：如short为-32768~32767,当short num = 32767时，输出结果为-32768；

【用sizeof求数据类型占用内存大小：sizeof（数据类型or变量）

如：short num1 =9；

cout<<”short占用空间内存为：“<<sizeof(short)<<end1;红色部分可为sizeof（num1）；】

2、浮点型

浮点数：float4字节

     double8字节

（在现在的c++中，输出小数只能显示6位有效数字，要想更多得装配置）

注意：在c++中，当定义float a=3.14时要在3.14后面加上“f“(即float a=3.14f；)，表示a为单精度浮点数，不然系统会默认小数a为double双精度；

科学计数法：如float f1=3e2//表示3*10^2;

                         float f2=3e^-2//表示3*0.1^2

3、字符型

   char ch2=’a’;只能单引号，引号里面只能有一个字母；

（字符型变量并不是把字符本身放到内存中存储，而是将对应的ASCII编码放入到存储单元）

字符型变量对应的ASCII编码，ch定义为一个字母a,要想输出其对应的ASCII码，只需在ch前面加上（int），即cout<<(int)ch<<end1;即可，实际上是用（int）强行将ch转换为一个整型变成一个实际性的数字让我们看到它。a为97；A为65；

4、字符串型

字符串型:

（1）c风格

char str[ ]=”helloworld”;

[ ]不能忘记，否则成了定义一个字符；

（2）c++风格字符串

string str2 = “helloworld“；

但前提是得有头文件：#include<string>;

【转义字符】

注意：要输出“\“一个反斜杠，则cout<<”\”<<end1;里面的反斜杠得写两个，

即正确的书写为cout<<”\\”<<end1;第一个反斜杠的意思是我要告诉编译器我要输出一个特殊的符号，第二个反斜杠即为我要输出的特殊符号；

\t为水平制表符：作用为使得8个字节的后面的开头一致位置

（案例：cout<<”aaa\t”<<end1;,我们在\t后面加上helloworld，即cout<<”aaa\thelloworld”<<end1;输出结果为aaa     helloworld；此时空格为5格，空格数的多少取决于前面字符数的多少，字符加上空格数等于8；优点如下展示：

cout<<”aaa\t”<<end1;

cout<<”aaaaaa\t”<<end1;

cout<<”aa\t”<<end1;

输出结果为：

  aaa     helloworld

  aaaaaa  helloworld

  aa      helloworld

可见无论前面如何，后面的hello world保持着一致位置。）

5、布尔类型

布尔类型bool（1字节）

代表真假，true-1；false-0；

例如：bool flag= true；

      cout<<flag<<end1;

          输出为1；

int a=0；

cout<<”请给整型变量a赋值：“<<end1;

cin>>a;（相当于scanf，自行输入a的值）

cout<<”整型变量a = “<<end1;

输出：

请给整型变量a赋值：6

整型变量a=6；

三、运算符

算术运算符：

++a；前置递增；先让变量+1，然后进行表达式运算；（先加再算）

a++;后置递增；先进行表达式运算，然后让变量+1；（先算后加）

（注意：两个小数是不可以做取模运算的，因为表达式必须具有整数或未区分范围的枚举类型）

赋值运算符：*= 等等……

比较运算符：!= 不相等……

如：int a=3, b=4;

cout<<(a==B)<<end1;

                 输出：0（假的）

逻辑运算符：

！ 非------！a

&&与------a&&b

||  或------a||b

int a=10;（c++中除了0都为真）

cout<<!a<<end1;a为真，则原本值为1，取非后变0

cout<<!!a<<end1;输出值为1；

三目运算符：

意义：比较谁大

（a>b?a:b）=100,谁大给前面int a=10，b=20；

c=（a>b?a:b）谁赋值为100

四、语句

1、do{循环语句}  while（循环条件）

2、break语句

一、出现switch条件语句中，作用是终止case并跳出switch；

二、出现在循环语句中，作用是跳出当前的循环语句；

三、出现在嵌套循环中，跳出最近的内循环语句；

3、continue

4、goto语句（不建议用）

五、数组

即里面存放了相同类型的数据元素的集合

特点一：数组中的每一个数据元素都是相同的数据类型；

特点二：数组是由连续的内存的位置组成的

定义方式：

  数据类型  数组名[数组长度]；

  数据类型  数组名[数组长度]={值1，值2，值3};

  数组类型  数组名[  ]= {值1，值2，值3};

sizeof(arr)为整个数组占用内存空间的大小；

sizeof（arr[0]）为每一个元素占用空间的大小；

sizeof（arr）/sizeof（arr[0]）为数组元素个数。

查看首地址：

（int）arr（原本输出的是16进制，前面加int后变成10进制）

（int）&arr[0],第一个元素的地址为。

二维数组：

//数据类型 数组名[行数][列数]={{数据1，数据2}，{数据3，数据4}}

输出后为：数据1   数据2

          数据3   数据4

//数据类型 数组名[2][3]={1,2,3,4,5,6};行数2可以不写；

sizeof（arr）二维数组占用内存空间为：

sizeof（arr[0]）二维数组第一行占用内存为；

sizeof（arr[0][0]）二维数组第一个元素占用内存

二维数组行数：sizeof（arr）/sizeof（arr[0]）;

二维数组列数：sizeof（arr[0]）/sizeof([0][0]);

六、函数

函数定义五步骤：

 1、返回值类型

 2、函数名字

 3、参数表列

 4、函数体语句

 5、return表达式

。。。。。。。。。。。。。。。。。。。。。

函数声明可以多次，但函数定义只能一次

返回值类型  函数名（参数表列）

{

      函数体语句；

    return表达式；

}（形参）

int mian（）

{

参数等于多少;

函数名（参数名称）；

}（实参）

如：int max（int a，int b）{

        return a>b?a:b;}

int main(){

    int a=10,b=20;

    cout<<max(a,b)<<endl;}

如果函数不需要返回值，声明时可以写 void;

返回值不需要时可以不写return；

重要知识，一定要好好理解

值传递：函数调用时实参将函数值传入给形参；

（值传递时，如果形参发生，并不会影响实参）

如：

#include<iostream>
using namespace std;
void swap(int num1 , int num2)
{
    int temp=num1;
    num1=num2;
    num2=temp;
    cout<<”交换后num1=”<<num1<<endl;
    cout<<”交换后num2=”<<num2<<endl;
}
int main()
{
    int a=10;
    int b=20;
    swap(a,b);
    cout<<”a=”<<a<<endl;
    cout<<”b=”<<b<<endl;
}

形参num1，num2，改变了并不影响实参a、b的值。

假如int main（）{}写前面了，可以在它前面写上函数声明，（函数声明可以写很多次）；

七、指针

指针的作用：可以通过指针间接访问内存

 内存编号是从0开始记录的，一般用16进制数字表示。可以利用指针变量保存地址，

……………………………

数据类型 * 变量名 如 int * p；

p=&a；让p指针去记录变量a的地址，用到“&“取地址符去获取地址

二合一：int * p= &a；

sizeof（int*）=sizeof（p）返回数据类型占用的内存（字节）32位操作系统下占用4字节，64位占8字节。

（a的地址为&a，指针p为p，p=&a，数值上相等）

空指针：

野指针：

const修饰指针

1）常量指针

   const int * p = &a；

   常量 指针   

特点：指针的指向可以修改，但是指针方向的值不能改变。

如：

const int * p = &a；

*p=20；错误，指针指向的值不可以修改

p=&b；正确，指针指向可以改。

2）指针常量

int * const p=&a；

指针 常量

特点：指针的指向不可以改，指针指向的值可以改

int *const p=&a；

*p=20；正确，指向的值可以改变

p=&b；错误，指针指向不可以改

3）const既修饰指针，又修饰常量

const int * const p =&a；

//利用指针访问数组：

int main(){
    int arr[10]={1,2,3,4,5,6,7,8,9,10};
    cout<<”利用指针访问第一个元素”<<*p<<endl;
    p++；//让指针向后偏移4个字节
    cout<<”利用指针访问第二个元素”<<*p<<endl;
}

地址传递

void swap（int* p1 , int* p2）{

    ……

}

int main(){

    ……

    swap(&a,&b);

}

重点：形参改变会影响实参

八、结构体

8.1 结构体

struct 结构体名{

        结构体成员列表

}；

创建结构体变量的方式：

1、struct 结构体名 变量名

2、struct 结构体名 变量名={成员1值，成员值}

3、定义结构体时随便创建

8.2 结构体数组

作用：将自定义的结构体放入到数组中方便维护

语法：struct 结构体名 数组名[元素个数]={   {}，{}，{}  }；

结构体变量利用操作符“.”访问成员

struct student
{
	string name;
	int age;
}；
int main(){
	struct(可以省略) student arr[3]={
		{zhang,18},
		{li,19},
		{liu,20}
    };
}

8.3 结构体指针

作用：通过指针访问结构体的成员

利用操作符->可以通过结构体指针访问结构体属性

struct student
{
	string name;
	int age;
}；
int main(){
	struct(可以省略) student s1={zhang,18};
	通过指针指向结构体变量	
struct student *p=&s1；
	通过指针访问结构体变量中的数据  
cout<<p->name<<endl;
}

8.4 结构体做函数参数

作用：将结构体作为参数向函数中转递

值传递

地址传递

作用：如果不想修改主函数中的数据，用值传递，反之用地址传递。

8.5 结构体中const使用场景

（作用：用const来防止误操作）

void printfstudent（const student *stu）

加了const后，在{ }中打stu->age=100；时会报错，防止不小心改变了原来的指针变量。因为用指针改形参时，实参会变化。

九、作用语句积累

1、随机数

随机数种子srand（（unsigned int）time（NULL））；

根据电脑的时间来给随机数种子给rand（）%101；

防止每一次给出的随机数相同。

 

（1）rand()%100   生成一个0到99的随机数

（2）添加随机数种子 作用利用当前系统时间生成随机数，防止每次随机数一样：

        using namespace std；

        #include<ctime>//头文件

        srand（（unsigned int）time（NULL））；里面的代码

        （while（1）死循环）