C ++基础入门

数据类型	占用空间	有效数字范围
单精度（float）	4字节	7位有效数字（2*4-1）
双精度（double）	8字节	15~16位有效数字（2*8-1）

有效数字：包括小数点前后的数字 eg：3.14->3位有效数字

默认输出一个小数，6位有效数字

3e2=3*10^2

3e-2=3*10^(-2)

字符型

char ch='a';

注意：

1.单引号

2.单引号内只能有一个字符

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

ASCII码

A---65

a---97

转义字符

回车键：\n “\n” eg：将“不错”回车

很

不错

反斜杠：\\ “\\”结果：\

水平制表符：\t 空格键 “\t” eg：不错灭

注意:出现/t,/t前面所有字符加上空格一共8个空格

字符串型

C语言风格

char str[]="hello world";

C++风格

String str1="hello world";

-->头文件要引入 #include<string>

布尔类型

数据类型 bool	内存空间
false 假 0	1字节
true 真 1	1字节

输入

布尔类型：非零输入结果都是1

随机数

程序流程结构

选择，循环，判断

选择：

switch：1.整型或是字符型

跳转：

1.switch

再循环内用if条件句用break退出循环

2.循环单层循环break直接退出循环进行下一语句

3.嵌套循环推出内层循环

continue

执行到本行就不再执行下一行代码了进行下一层的循环

goto：直接跳转到FLAG：

goto FLAG;

FLAG:

******;

、

数组

定义方式

一维数组：

1.int arr[5];

~~arr[0]=0;~~

~~arr[1]=1;~~

~~arr[2]=2;~~

~~arr[3]=3;~~

~~arr[4]=4;~~

可以用循环实现·

2.int arr2[5]={2,1,4,5,6};

如果在初始化这个数据，没有全部填写完，则用0填补

3.int arr3[]={1,2,3,4,4,5,5,5};

定义数组必须有初始长度

二维数组：

1.int arr[2][3];

嵌套循环输入

arr[0][1]=0;

arr[0][2]=1;

....................

2.arr[2][3]={ 比较清晰常用

{1,2,3},

{4,5,6}

};

3.arr[2][3]={1,2,3,4,5,6};

4.arr[][3]={1,2,3,4,5,6};

以上所有结果都是一样的

数组名的用途

一维数组：

1.获取数组长度

arr[10];

sizeof（arr）/sizeof(arr[0]);-->40/4=10;

sizeof（arr）-->4*10=40;

sizeof(arr[0])-->4;

2.数组地址

(int)arr

arr

二维数组：

1.获取数组长度

arr[2][3];

sizeof(arr)/sizeof(arr[0][0])

总个数：6

cout<<sizeof(arr)/sizeof(arr[0][0])<<endl;

行：2

cout<<sizeof(arr)/sizeof(arr[0][0])<<endl/cout<<sizeof(arr[0])/sizeof(arr[0][0])<<endl;

列：3

cout<<sizeof(arr[0])/sizeof(arr[0][0])<<endl；

2.数组地址

首地址和第一行数据地址是一样的

arr[2][3];

arr[0]==arr;

cout<<arr[0]<<endl;

cout<<arr[1]<<endl;

数组第一二行首地址

函数

函数的定义

1.返回值类型

数据类型

int double bool....

【要return，return num；】

void

【不用return，或者return；】

2.函数名 add 加法函数

3.参数列表（int num1,int num2）

4.函数体语句 int sum=num1+num2;

5.return表达式 return sum;

加法函数

int add(int num1,int num2){

int sum=num1+num2;

return sum;

}

num1,num2是形参

函数的调用

函数名称（参数）；

eg:add(a,b);

如果函数没有参数则不用传入参数

a,b是实参

当调用函数是实参传给了形参

值传递：形参发生任何改变，实参不会发生任何改变

地址传递：

函数常见样式

1.无参无返

void test01( ){

cout<<"this is test01"<<endl;

}

2.有参无返

void test02(int num1 ){

cout<<"this is test01"<<num1<<endl;

}

3.无参有返

int test03( ){

cout<<"this is test01"<<endl;

return 1000;

}

4有参有返

int test04(int num1,int num2 ){

cout<<"this is test01"<<endl;

int sum=num1+num2;

return sum;

}

主函数：

int main(){

test01();

test02(100);

test03();

test04(2,3);

}

函数声明

声明有多次，定义只能有一次

一般函数要写在前面

要在总函数上面声明

int add(int a,int b);

int main(){

int c=add(2,2);}

int add(int a,int b){

int sum=a+b;

return sum;

}

函数的分文件编写

头文件.h

-->函数声明

#include<iostream>

using namespace std;

void swap(int a,int b);

源文件.cpp

-->函数体

#include"swap.h"

void swap(int a,int b){

int t;

t=a;

a=b;

b=t;

}

源文件

#include<iostream>

using namespace std;

#include"swap.h"

int main(){

int a=10;

int b=119;

swap(a,b);

return 0;

}

指针

定义指针

int a=10;

int* p;

p=&a;

引用指针

-->解引用

*p是指p地址指向的值，内存内存储的值。

*p可以访问值也可以修改值；

*p=10;

*p=100;

a=100;

指针占内存空间

int* |double* |float* |char*

-->均为4个字节（32位操作系统）

/均为8个字节（位64操作系统）

空指针和野指针

-->都是不是我们申请的空间，因此不要访问

空指针

1.空指针用于给指针变量进行初始化

int* p=NULL;

2.空指针是不可以进行访问的

*p=100;

-->不可以直接访问修改

0~255之间的内存编号是系统占用的，因此不可以访问

const修饰指针

1.常量指针

const修饰指针指向的值

a=10;

const int*p=&a;

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

个人理解：

const *p

*p是指针指向的值，const修饰的是这个故而不能改

2.指针常量

const修饰指针

a=10;

int* const p=&a;

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

个人理解：

const p

p是指针指向的地址，const修饰的是这个故而不能改

3.const修饰指针和指针指向的值

a=10;

const int* const p=&a;

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

个人理解：

const p

const* p

p是指针指向的地址和指针指向的值，const修饰的是这两个故而不能改

指针和数组

1.用指针访问数组中的每一个元素

int arr[5]={1,2,3,4,5}；

int* p=arr;

for(int i=0;i<5;i++){

cout<<*p<<endl;

p++;}

指针和函数

地址传递

swap(int* a,int* b){

int t;

t=*a;

*a=*b;

*b=t;

}

int main(){

int a=10;

int b=20;

cout<<a<<b<<endl;

swap(&a,&b);

cout<<a<<b<<endl;

}

结构体

基本概念

：自定义的数据类型

定义结构体

struct Student{

string name;

int age;

double score;

};

注意：

struct必须要有

创建结构体

三种方式

1.~~struct~~ Student s1;

创建结构体struct可以省略，定义结构体时不可省略

赋值：

s1.name="张三";

s1.age=12;

s1.score=90;

2.~~struct~~ Student s1={"张三"，12，90};

3.struct Student{

string name;

int age;

double score;

}s1;

int main(){

s1.name="张三";

s1.age=12;

s1.score=90;

}

结构体数组

1.定义结构体

struct Student{

string name;

int age;

double score;

};

2.创建结构体

int main(){

Student stuarray[8]=

{

{"张三",12,45},

{"李四",12,56},

{"王五",12,89}

};

3.赋值

stuarray[2].name="赵六"；

//后面可以修改

}

4.遍历

for(int i=0;i<3;i++){

cout<<stuarray[i].name<<stuarray[i].age<<stuarray[i].score<<endl;

}

结构体指针

uct Student{

string name;

int age;

double score;

};

int main(){

1.创建学生结构体变量

Student s={"张三"，23，50};

2.通过指针指向结构体变量

Student* p=&s;

3.通过指针访问结构体变量中的数据

cout<<p->name<<p->age<<p->score<<endl;

return 0;

}

结构体嵌套结构体

个人理解概念

：可以将另一结构体作为自己结构体的一个成员

1.定义结构体

struct teacher{
    string name;
    int id;//老师编号
    int age;
    Student stu;
};
struct Student{
    string name;
    int age;
    double score;
};
int main(){
    teacher t;
    t.id=10000;
    t.name=45;
    t.stu.name="李四";
    t.stu.age=18;
    t.stu.score=78;
}

结构体做函数参数

作用

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

传递方式

：

值传递
地址传递

struct Student{
    string name;
    int age;
    double score;
};
void printStudent1(Student s1){
    cout<<s1.name<<s1.age<<s1.score<<endl;
}
void printStudent2(Student* s2){
    cout<<s2->name<<s2->age<<s2->score<<endl;
}
int main(){
    Student s1;
    s1.name="张三";
    s1.age=12;
    s1.score=90;
    printStudent1(s1);
    //值传递
    printStudent2(&s1);
    //地址传递
}

结构体中const使用场景

struct Student{
    string name;
    int age;
    double score;
};
void printStudent2(const Student* s2){
    //加入const一旦有修改操作就会报错不想数据改变
    cout<<s2->name<<s2->age<<s2->score<<endl;
}
int main(){
    Student s1;
    s1.name="张三";
    s1.age=12;
    s1.score=90;
    printStudent2(&s1);//节省内存空间，函数值变主函数也变
}