c++小结

---

一.C++与C的区别

1. 头文件

C以.h结尾
C++无拓展名

2.字符串

2.1 头文件

C++中使用字符串要加头文件string
C中不用添加

2.2 风格

C风格字符串： char 变量名[] = “字符串值”
C++风格字符串：string 变量名 = “字符串值”

3.C++中新增变量类型bool

bool类型有两种内建常量true（转化为整数1）和false（转换为整数0）表示状态。//bool、true、false都为关键字

4.赋值

C中的赋值只有一种：‘=’
C++中除了使用‘=’外，还可以使用‘()’

5. 结构体

C中struct关键字不能省略
C++中struct关键字可以省略

二.记忆不深的知识点

1.逻辑运算符

2.结构体

2.1数组

语法: struct 结构体名 数组名{元素个数}={ {}，{}，…{} }

示例：

//结构体定义
struct student
{
    //成员列表
    string name;//名字
    int sex;	//性别
    int age;    //年龄
};
int main(){
    //结构体数组
    struct student a[3]=
    {
        {"张三","男",18},
        {"李四","男",20},
        {"王五","男",22}
    }
    
    return 0;
}

2.2指针

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

示例：

//结构体定义
struct student
{
    //成员列表
    string name;//名字
    int sex;	//性别
    int age;    //年龄
};
int main(){
    //创建学生变量
    struct student stu = {"张三","男",18};
    //通过指针指向结构体变量
    struct student * p = &stu;
    //通过指针访问结构体变量中的数据
    cout<<"姓名："<< p->name<<"年龄:"<< p->age<<"分数:"<< p->score<<endl; 
    
    return 0;
}

2.3结构体嵌套

结构体中成员可以是另一个结构体

示例：

struct person
{
	string stuID;//学号
	string name;//名字
	int sex;//性别
	int age;//年龄
	string allscore;//总成绩
};
struct eas
{
	struct person personarray[1000];
	int size;//学生人数
};

三.C++核心编程

1.内存分区模型

C++程序执行时，将内存大方向分为4个区域
1）代码区：存放函数体的二进制代码，由操作系统进行管理
2）全局区：存放全局变量和静态变量以及常量
3）栈区：由编译器自动分配释放，存放函数的参数值，局部变量等
4）堆区：有程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

1.1程序运行前

在程序编译后，尚未执行前程序分为两个区域
代码区：
存放CPU执行的机器指令
代码区是共享的（对于频繁被执行的程序，只需要在内存中有一份代码）
代码区是只读的（防止程序意外的修改它的指令）
全局区
全局变量和静态变量存放在此
全局区还包含了常量区，字符串常量和其他常量也存放在此
该区域的数据在程序结束后由操作系统释放
取全局变量地址：

int a=10;
cout<<"全局变量g_a的地址为"<<(int)&g_a<<engl;

取静态变量地址：

在普通变量前加static，属于静态变量

static int s_a=10;
sout<<"静态变量s_a的地址为"<<(int)&s_a<<endl;

取字符串常量地址：

cout<<"字符串常量的地址为"<<(int)&"hello world"

在变量前加const为常量

取全局常量地址：

const int c_g_a=10;
cout<<"全局常量c_g_a的地址为"<<(int)&c_g_a<<endl;

取局部常量地址：

const int c_l_a=10;
cout<<"局部常量c_l_a的地址为"<<(int)&c_l_a<<endl;

1.2程序运行后

栈区
由编译器自动分配释放，存放函数的参数值，局部变量等
数据注意事项 ：
1）不要返回局部变量的地址
2）栈区的数据由编译器管理开辟和释放

堆区
由程序员分配释放，若程序员不释，程序结束时由操作系统回收
在C++中主要用new在堆区开辟内存
示例：

指针也是局部变量，放在栈上，指针保存的数据放在堆区

int*f()
{
   int*a=new int(10);
   return a;
}
int main()
{
   int *p=f();
   cout<<*p<<endl;
   cout<<8p<<endl;
   system("pause");
   return 0;
}

1.3 new操作符

示例（语法）：

int*f()
{
   int*a=new int(10);
   return a;
}
int main()
{
   int *p=f();
   cout<<*p<<endl;
   cout<<8p<<endl;
   system("pause");
   return 0;
}

2.引用

本质：指针常量

void f(int &a)
{
   a=100; //自动转化为*a=100
}

2.1语法

语法：数据类型 &别名=原名

int a=10;
int &b=a;//创建引用

2.2引用注意事项

1）引用必须初始化
2）引用初始化后不可变

因为引用本质为指针常量，而指针常量中指针指向不可变

int a=10;
int &c;//错误，未初始化
int &c=a;

2.3引用做函数参数

作用：函数传参时，可利用引用的技术让形参饰形参
优点：可简化指针

//值传递
void swap1(int a,int b)
{
     int temp=a;
     a=b;
     b=temp;
}
//地址传递
void swap2(int *a,int*b)
{
    int temp=*a;
    *a=*b;
    *b=temp;
}
//引用传值
void swap3(int &a,int &b)
{
   int temp=a;
   a=b;
   b=temp;
}

2.4引用做函数返回值

注意：不要返回局部变量引用
用法：函数调用为左值

2.5常量引用

作用：常量引用主要用来修饰形参，防止误操作（加const修饰形参）

int main()
{
  const int &a=10;
 //编译器优化代码为：int temp=10;const int& a=temp;
 //加入const后不可修改变量；

3.函数

3.1默认参数

语法：返回值类型 函数名（参数=默认值）
注意：
1.一个位置参数有默认值，那么这个位置往后，必须要有默认值
2.函数声明与函数实现不能同时有默认参数

3.2占位参数

语法：返回值类型 函数名 （数据类型）
注意：
1.占位参数也可以有默认参数
2.函数调用时占位参数必须填补

3.3函数重载

作用：函数名可以相同，，提高复用性
满足条件：
1.同一作用域下
2.函数名称相同
3.函数参数类型不同 / 个数不同 / 顺序不同
注意：
1.函数的返回值不可以作为函数重载的条件
2.引用可作为重载的条件
3.用函数重载时最好不要加默认参数
示例：

void f();
void f(int a);//参数不同

void f(int a);
void f(double a);//参数类型不同

void f(int a,double b);
void f(double a,int b);//参数顺序不同

4.类和对象

C++面向对象的三大特征：封装、继承、多态

4.1封装

意义：
1.将属性和行为作为一个整体，表现生活中的事物

• 语法：class( 默认权限为私有 ) / struct( 默认权限为公共 ) 类名{访问权限：属性 / 行为}；
• 示例：

//设计求圆的周长
#include<iostream>
using namespace std;
const double PI=3.14;
class circle
{
public:  //公共权限(访问权限)
int m_r; //半径（属性）
double calculateZC()
{
    return 2*PI*m_r;
}//行为（获取圆的周长）
};//注意加分号
int main()
{   
    Circle c1:    //创建具体的圆（对象）
    c1.m_r=10;    //给圆对象的属性进行赋值
}

2.将属性和行为加以权限控制

访问权限

• public（公共权限）

类内可访问，类外可访问

• protected（保护权限）

类内可访问，类外不可访问

• private（私有权限）

类内可访问，类外不可访问
优点：
1.将所有成员属性设置为私有，可以自己控制读写权限
2.对于写权限，我们可以检测数据的有效性

4.2对象特征

1.构造函数和析构函数（这两个函数会被编译器自动调用）
作用：完成对象初始化和清理工作

1）构造函数：主要作用在于创建对象是为对象的成员属性赋值，构造函数由编译器自动调用，无须手动调用

语法：类名（）{}

注意：

1.没有返回值不写void
2.函数名与类名相同
3.可以有参数，因此可以发生重载
4.程序在调用对象是会自动调用构造，无须手动调用，而且只会调用一次

分类 ：

• 按参数：有参结构 和 无参结构（默认构造）
• 按类型：

1）普通结构

2） 拷贝构造
调用时机：

• 使用一个已经创建完毕的对象来初始化一个新对象

void test()
{
     person p1(20);
     person p2(p1);
     cout<<p2的年龄为："<<p2.m_age<<endl;
}

• 值传递的方式给函数参数传值

void dowork (person p)
{}
void test()
{
    person p;
    dowork(p)
}

• 以值方式返回局部对象

person dowork()
{
    person p1;
    return p1;
}
void test()
{
    person p=dowork() 
}

调用方式：

1）括号法：

person p1（10）
//调用无参构造函数时若加了括号，编译器会认为这是函数声明

2）显示法:

person p2=person(10)
person p3=person(p2)
//person（10）单独写就是匿名对象，当前行结束后，马上析构

3）隐式转换法:

person p4=10
person p5=p4
//若用拷贝构造函数初始化匿名对象，编译器会认为这是对象声明

2） 析构函数：主要作用在于对象销毁前系统调用，执行一些清理工作

语法：~类名（）{}

注意

1.没有返回值不写void
2.不可以有参数，因此不可以发生重载
3.程序在对像销毁前会自动调用析构，无须手动调用，而且只会调用一次