【无标题】7 c++基础自用

运算符类型	作用	符号
算术运算符	四则运算	+ - * / % ++ --
赋值运算符	表达式赋值给变量	= += -= *= /= %=
比较运算符	比较返回真假	== != < > <= >=
逻辑运算符	根据表达式值返回真值、假值	! && \|\|

求余%需整型

4程序流程结构

1）选择结构（if 、三目、switch）

1.1if

作用：判断

单行格式	if(条件){条件满足执行的语句};
多行格式	if(条件){条件满足执行的语句}else{条件不满足执行的语句};
多条件格式	if(){}else if(){}...else{};

格式
可以嵌套

1.2三目运算符

作用：判断
格式：表达式1?表达式2：表达式3
说明：1真执行2，返回2的值。1假执行3，返回3的值

1.3switch语句

作用：多条件分支
格式：switch(){case结果1:执行语句;break;case结果2:执行语句;break;...default:执行语句;break}

2）循环结构（while、do...while、for）

2.1while

作用：
格式：while(条件){循环语句}

2.2do...while

作用：
格式：do{循环语句 }while(条件);
先执行一次

2.3for

作用
格式：for(起始表达式;条件表达式;改循环状态表达式){循环语句;}

2.4嵌套

3）跳转语句（break、continue、goto）

3.1break

作用：跳出选择或者循环
时机：

switch中	，终止case并跳出switch
循环	跳出当前循环循环语句
嵌套	跳当前循环

3.2continue

作用：循环中，跳本次循环，执行下一次

3.3goto

作用：无条件跳转
格式：goto 标记；

5数组

1）

一个集合，存放了相同的元素
特点：数组中每个元素都是相同的\由连续的内存位置组成的

2）一维数组

定义：

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

数据类型数组名[数组长度] = {值};

数据类型数组名 [] = {值};

数组名：统计长度、获取数组在内存的首地址

3）二维数组

定义：利用第二种更为直观

数组类型数组名[行号][列号];

数组类型数组名[行号][列号] = {{值},{值}}；

数组类型数组名[行号][列号] = {值};

数组类型数组名[ ][列号] = {值};

数组名：查看所占内存空间、获取二维数组首地址

6函数

1）

作用：将一段经常使用的代码（功能）封装

2）定义

5步骤：返回值类型、函数名、参数列表、函数体语句、return 表达式
格式：返回值类型函数名（参数列表）{函数体语句；return表达式；}

3）调用

格式：函数名（函数）

4）值传递

即实参只是将数值传入形参中。形参发生变化，并不影响实参。

5）函数的常见样式

无参无返、有参无返、无参有返、有参有返

6）函数声明

作用：告诉编译器函数名称以及如何调用函数。后汉书的实际主体可以单独定义
函数声明可以多次，函数定义只有一次

7）函数分文件编写

创建后缀为.h的头文件==写声明、后缀为.cpp的源文件==写定义、

7指针

1）

通过指针间接访问内存。
内存编号从0开始记录，十六进制数字表示
可以利用指针变量保存地址

2）定义与使用

格式：数据类型 * 变量名;

//定义
int a = 10;
int * p ;
p = &a;
//使用
//解引用
cout<<"*p = "<<*p<<endl;

3）所占空间

4或8字节，看多少位机

4）空指针或野指针

空指针：指向编号为0的空间。其用途：初始化指针。不可访问
野指针：指向非法的内存空间。（一个没有对象的野指针）。不可访问

5）const修饰指针

3情况：在int a=10;下

修饰指针--常量指针	const int * p1=&a;	指针指向可以变，指向的值不可变
修饰常量--指针常量	int * const p2=&a;	指针指向不可变，指向的值可变
都修饰	const int* const p3=&a;	都不能变

6）指针与数组

利用指针访问数组元素
注意符号->

7）指针与函数

值传递与地址传递

8）指针、数组、函数结合

8 结构体

1）

结构体属于用户自定义的数据类型，允许用户存储不同的数据类型

2 ）定义与使用

格式：struct 结构体名 {结构体成员列表}；
创建变量的三种方式：

struct 结构体名变量名

struct 结构体名变量名 = {成员}；

定义结构体时顺便创建

void text() {
	struct Student {
		string name;
		int age;
		int score;
	}stu2;//创建方法2

	stu2.name = "李四";

	struct Student stu1;//创建方法1
	stu1.age = 18;
	stu1.score = 99;
	stu1.name = "张三";

	cout << stu1.name<<"\t" << stu1.age << "岁\t" << "语文成绩:"<<stu1.score <<"分\t"<< endl;
	
	cout << "有一个同学叫做" << stu2.name << endl;
}

3）结构体数组

将定义的结构体放入到数组中==方便
格式：struct 结构体名数组名[元素个数] = {{}，{}，...};

4）结构体指针

作用：通过指针访问结构体中成员
操作符：->。访问结构体属性

5）结构体嵌套结构体

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

6）结构体做函数参数

作用：将结构体作为参数向函数传递
传递方式：值、址（推荐）
===》函数名（&结构体变量名）
定义（例）：void text(struct student * p){}

7）结构体中const的使用

与之前差不多（在前值不可变，在后指向不可变）

其他

二

对面向对象的进一步学习

1始

1）c++程序执行时，将内存大方向分为4个区域

代码区	存放函数体的二进制代码，由操作系统进行管理	共享，只读。程序运行前
全局区	存放全局变量，静态变量，常量	操作系统释放。程序运行前
栈区	编译器自动分配释放，存放函数参数、局部变量等	不要返回局部变量地址。程序运行后
堆区	程序员分配释放，未释放则在程序结束由操作系统释放	利用new开辟。程序运行后

意义：灵活编程

2new关键字

堆区开辟空间，程序员手动开辟释放，释放：delete

格式：new 数据类型

new返回的是这个数据类型的指针

#include<iostream>
using namespace std;

int* func() {
	int* a = new int(10);
	return a;
}

int main() {
	int* p = func();
	cout << *p << endl;//*解引用，表示的是值
    delete p;//释放堆区数据
	system("pause");
}

3引用

作用：给变量起别名

格式：数据类型 &别名=原名

注意：引用必须初始化，一旦初始化便不能更改

int a = 10;
int b = 20;
//int &c ;//未初始化
int &c = a;//初始化后不能更改
c = b;//赋值操作，不是更改

3.1）引用做函数参数

作用：让形参修饰实参

优点：简化指针修改实参

void myswap1(int a,int b) {//值传递
	int temp = a;
	a = b;
	b = temp;
}
void myswap2(int* a, int* b) {//地址传递
	int temp = *a;
	*a = *b;
	*b = temp;
}
void myswap3(int &a, int &b) {//引用传递
	int temp = a;
	a = b;
	b = temp;
}

	//int a = 10;
	//int b = 20;
	//myswap1(a,b);//值传递，不改变实参
	//myswap2(&a,&b);//地址传递，改变实参
	//myswap3(a,b);//引用传递，改变实参

3.2)引用做函数返回值

作用：引用做函数返回值

注意：不要返回局部变量引用

用法：函数调用作为左值

int& text01() {
	int a = 10;//局部变量
	return a;
}

int& text02() {
	static int a = 10;//全局变量
	return a;
}


	int &c = text01();
	cout << c << endl;//第一次结果正确，编译器保留
	cout << c;//第二次结果错误，a的内存已经释放

3.3）引用的本质

在c++内部实现一个指针常量

void text02(int& re) {//引用自动转换：int* const re = &a;
	re = 100;//转换：*re = 100;
}

void text01() {
	int a = 10;
	int& tep = a;//引用自动转换：int* const tep = &a;指针常量是指针指向不可更改
	tep = 20;//转换：*tep = 100;
	cout << a << endl;
	cout << tep << endl;
	text02(a);
	cout << a << endl;
	cout << tep << endl;
}

//结果10 10 100 100

3.4）常量引用

作用：防止误操作

格式：const 数据类型& 形参名

4函数+

4.1）函数默认参数

格式：返回值类型函数名（参数 = 默认值）{}

注意：①某位置有默认参数，该位置往后必须有默认参数②函数声明有默认参数，函数实现（定义）不能有默认函数

4.2）函数占位参数

形参表里可以有占位参数，用来占位，调用函数时必须填补

格式：返回值类型函数名 (数据类型) {}

4.3）函数重载

作用：函数名可以相同，提高复用性

条件：①同一个作用域下②函数名相同③函数参数类型不同或个数不同或顺序不同

注意：函数返回值不可以作为函数重载的条件

注意事项：①引用作为重载条件√②碰到默认参数×会出错

5类、对象

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

万物皆可为对象

5.1）封装

5.1.1）

意义1：

将属性和行为作为一个整体，表型生活中的事物

将属性和行为加以控制

格式：class 类名{ 访问权限：属性/行为 }；

实例：学生类

class student {//定义学生类
public:
	string m_name;
	int m_age;

public:
	void setstu(string name,int age) {//赋信息的方法
		m_name = name;
		m_age = age;
	}
	
	void showstu() {//显示信息的方法
		cout << "姓名：" << m_name << "\t年龄：" << m_age << endl;
	}
};
void text() {
	student st1;
	st1.setstu("张三",18);
	st1.showstu();
}

意义2：访问权限

public	公共权限	类内可以访问，类外可以访问
protected	保护权限	类内可以访问，类外不可以访问，儿子可以访问父亲保护的内容
private	私有权限	类内可以访问，类外不可以访问，儿子不可以访问父亲保护的内容

成员属性设置为私有的优点：

可以自己控制读写权限
对于写权限，可以检测数据的有效性

5.1.2）struct与class的区别

默认的访问权限不同：

struct默认权限为公共
class默认权限为私有

5.2）对象的初始化和清理

出厂设置...删除数据

5.2.1）构造函数与析构函数

对象或变量未初始化，对其使用后果未知

使用完的对象和变量未及时清理，有安全问题

构造函数与析构函数解决上述。编译器自动调用，我们不提供，系统自动提供空实现

构造函数	创建对象时为对象的成员属性赋值
析构函数	在对象清理前自动调用，执行清理工作

构造函数语法：类名（）{}

没有返回值也不写void
函数名与类名相同
可以有参数，因此可以发生重载
自动调用，执行一次

析构函数语法：~类名（）{}

没有返回值也不写void
函数名与类名相同，在类名前加~
不可以有参数，因此不可以发生重载
自动调用，执行一次

如上述例子的学生类中：student st1;//为栈上数据，在执行完text（）后，释放这个对象

5.2.2）构造函数的分类与调用

两种分类方式：

按参数分类：有/无

按类型分类：普通/拷贝构造

Person(const Person &p){//拷贝构造
    //将传入的人身上的所以属性，拷贝到我的身上
    m_age = p.age;
}

三种调用方式：

括号法；

Person p1;//默认构造函数，不要写（），否则会认为是一个声明
Person p2(10);//有参构造
Person p3(p2);//拷贝构造

显示法；

Person p1;
Person p2 = Person(10);
Person p3 = Person(p2);

Person(10);//匿名构造，特点：当前行执行完，系统会立即回收匿名函数,即马上析构

//不要用拷贝构造初始化匿名对象，如：Person(p3);

隐私转换法；

Person p4 = 10;//相当于Person p4 =  Person(10);
Person p5 = p4;

5.2.3）拷贝函数的调用时机

3情况：

使用一个已经创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值
以值方式返回局部对象

void dowor(Person p){//第二种
}
void text02(){
Person p2;
dowor(p2);
}

//第三种
Person dowoo(){
Person p3;
//cout<<(int*)&p3<<endl;
return p3;
}

void text(){
Person p = dowoo();
//cout<<(int*)&p<<endl;\
}

5.2.4)构造函数的调用规则

默认，c++编译器至少给一个类添加3个函数

默认构造函数（无参，函数体为空）
默认析构函数（无参，函数体为空）
默认拷贝构造函数，对属性值拷贝

构造函数调用规则如下：

用户定义有参构造，c++不提供默认构造函数，但提供默认拷贝构造
用户定义拷贝构造，c++不提供其他

5.2.5）深拷贝，浅拷贝

浅拷贝	简单拷贝	（自己理解）如果开辟了空间，拷贝仍然指向同一个堆中区域、空间的值，在某一方释放该空间时会让另一方出错（重复释放）
深拷贝	在堆区重新申请空间，进行拷贝（new）	再开辟空间（重构拷贝用深拷贝解决浅拷贝问题）

析构代码：将堆区开辟的数据做释放操作

m_heig = new int(heih);//再开辟
~Person(){
    if(m_heig != NULL){
    delete m_heig;
    m_heig = NULL;
    }
}

例子：

class person {
public:
	person(){
		cout << "无参构造" << endl;
		mage = 0;
		mhhhe = 0;
	}
	person(int age, int hhhe) {
		cout << "有参构造" << endl;
		mage = age;
		mhhhe = new int(hhhe);
	}
	person(const person& p) {
		cout << "拷贝构造" << endl;
		mage = p.mage;
		//mhhhe = p.mhhhe;//浅拷贝，默认拷贝
		mhhhe =  new int(*p.mhhhe);//深拷贝，重构拷贝
	}
	~person() {
		if (mhhhe != NULL) {
			delete mhhhe;
			mhhhe = NULL;
		}
		cout << "析构函数" << endl;
	}
public:
	int mage;
	int *mhhhe;

};


void text() {
	person p1(10,20);
	cout << p1.mage << endl;
	cout << *p1.mhhhe << endl;
	person p2(p1);
	cout << p2.mage << endl;
	cout << *p2.mhhhe << endl;
}

浅拷贝（默认拷贝会发生问题）

5.2.6）初始化列表

作用：初始化属性

格式：构造函数()：属性(值1),属性(值2)...{}

Person(int a,int b):ma(a),mb(b)//初始化列表
{}//初始化列表
int ma;
int mb;
};//上面是在类内

Person p(10,20);//调用

5.2.7）类对象做类成员

例：

class A{}
class B{
    A a;
}
//我拿我的手机
//a构造--b构造--b析构--a析构

5.2.8）静态成员

静态成员就是在成员变量或成员函数前加关键字static

静态成员变量

所有对象共用一份数据

在编译阶段分配数据

类内声明，类外初始化

静态成员函数

所有对象共用一个函数

静态成员函数只能访问静态成员变量

class person {
public:
	static int ma;//类内声明
};
int person::ma = 100;//类外定义（初始化）

静态成员的访问2种方式

void text() {
	//1，创建对象
	person p1;
	cout << p1.ma << endl;
	//2，通过类名
	cout << person::ma << endl;
}

静态成员也有访问权限，不同权限下，访问结果不同；

5.3）c++对象模型、this指针

5.3.1）成员变量和成员函数分开存储

只有非静态成员变量才属于类的对象上，占对象空间。静态成员变量，成员函数（一个函数实例）都不占

c++会为每个空对象分配一个空间

5.3.2）this指针概念

解决5.3.1中代码如何区分一个函数实例问题，（如何知道是自己的函数）

this指针指向被调动的成员函数所属的对象。（谁调用指谁）

this指针是隐含在每一个非静态成员函数内的一种指针

不需要定义，直接使用

用途：

当形参和成员变量同名时，可以用this区分

在类的非静态成员函数中返回对象本身，可以用return *this

5.3.3）空指针访问成员函数

空指针也可以调用成员函数的，但是也要注意有没有用到this指针

如果用到this指针，需要加以判断代码健全性

if (this == NULL) {
	return;
}

5.3.4）const修饰成员函数

常函数

成员函数加上const后称为常函数

常函数不可修改成员属性

成员属性声明时加关键字mutable后，在常函数中依旧可以修改

常对象

声明（实例）对象前加const称为常对象

常对象只能调用常函数

5.4）友元friend

有些私属性，可让类外特殊的一些函数或类访问

让一个函数或类访问另一个类中私有成员

友元关键字：friend

友元的三种实现

全局函数做友元

类做友元

成员函数做友元

5.5）运算符重载operator

对已有的运算符重新定义，赋予其另一种功能，以适应不同的数据类型（自定义类型）

关键字：operator

//例 加法
class jia1 {
public:
	int a ;
	//通过成员函数重载
	jia1 operator+ (jia1 jiaa) {//对应j5
		jia1 temp;
		temp.a = jiaa.a + this->a;
		return temp;
	}
};

jia1 jiafacongzai(jia1 jiaa, jia1 jiaaa) {//以函数方式，对应j4
	jia1 temp;
	temp.a = jiaa.a + jiaaa.a;
	return temp;
}
//通过全局函数重载
//jia1 operator+(jia1 jiaa, jia1 jiaaa) {//关键字operator可简化函数名不写，对应j5
//	jia1 temp;
//	temp.a = jiaa.a + jiaaa.a;
//	return temp;
//}

void jia() {
	jia1 j1;
	j1.a = 10;
	jia1 j2;
	j2.a = 20;
	jia1 j3;
	j3.a = j1.a + j2.a;//普通加法
	cout << j3.a << endl;
	jia1 j4;
	j4 = jiafacongzai(j1, j2);
	cout << j4.a << endl;
	jia1 j5 = j1 + j2;
}

另：c++编译器给一个类添加4个函数

默认构造函数，无参，函数体为空

默认析构函数，无参，函数体为空

默认拷贝函数，无参，对属性进行值拷贝

赋值运算符operator=，对属性进行值拷贝

5.6）继承

面向对象的三大特性之一

5.6.1）

优点：减少重复代码

格式：class 子类：继承方式父类

子类又名派生类，父类又名基类

子类成员：

一是继承过来的（表现共性），二是自己增添的（表现个性）

继承方式：

公共继承	public	继承过来后变为公共属性
保护继承	protected	继承过来后变为保护属性
私有继承	private	继承过来后变为私有属性

父类中继承过来的属性：

公共属性	可访问
保护属性	可访问
私有属性	也继承过来了，不可访问，

继承的构造和析构顺序：

父类构造--子类构造--子类析构--父类析构

继承同名处理方式：（通过子类访问时）

子类出现父类同名的成员函数，会隐藏父类的

访问子类同名成员：直接访问
访问父类同名成员：通过作用域访问（base::）

多继承：

格式：class 子类：继承方式父类1，继承方式父类2
同名加作用域区分

菱形继承：

两个派生类b'c继承同一个基类a，又有某个类c同时继承两个派生类

菱形继承问题：基类a中的某份数据会重复继承

解决方法，虚继承：在继承之前加上关键字virtual

class A{};
class B:virtual public A{};
class c:virtual public A{};
//

5.7)多态

面向对象的三大特性之一

分为两类：

静态多态	函数重载和运算符重载属于静态多态，复用函数名	的函数地址早绑定：编译阶段确定函数地址
动态多态	派生类和虚函数运行时多态	的函数地址晚绑定：运行阶段确定函数地址

动态多态满足条件：

有继承关系
子类重写父类的虚函数

动态多态的使用：

父类的指针或引用，执行子类对象

多态优点：

代码组织结构清晰
可读性强
利于前期和后期的扩展和维护

例

class Animal {
public:
	virtual void move() {//缺少virtual的时候，结果都为“动物在走”
		cout << "动物在走" << endl;
	}
};

class cat :public Animal {
public:
	void move() {
		cout << "猫在走猫步" << endl;
	}
};

class big :public Animal {
public:
	void move() {
		cout << "猪在跳舞" << endl;
	}
};

void moveaaa(Animal& animal) {
	animal.move();
}

void text() {
	cout << "zhixin " << endl;

	cat cat1;
	moveaaa(cat1);

	big big1;
	moveaaa(big1);
}

纯虚函数/抽象类：

多态中父类的虚函数实现是无意义的，可转换为纯虚函数
格式：virtual 返回值类型函数名（参数列表） = 0；
当类中有纯虚函数，这个类称为抽象类

抽象类特点：

无法实例化对象
子类必须重写抽象类中的纯虚函数，否则也是抽象类
```
virtual void move() = 0;
```

虚析构和纯虚析构：

多态使用时，如果子类中有属性开辟到堆区，那么父类在释放时无法调用到子类的析构代码

Animal * animal = new Cat("tom");//这种情况下

解决方法：将父类中的析构函数改为虚析构或纯虚析构

虚析构和纯虚析构共性：

可以解决父类指针释放子类对象
都要有具体的函数实现

虚析构和纯虚析构区别：

如果是纯虚函数，该类属于抽象类，无法实例化对象

虚析构格式：

virtual ~类名(){}

纯虚析构格式：

virtual ~类名() = 0;
类名::~类名(){}

6文件操作

程序运行产生的数据属于临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化

6.1）

C++中对文件操作需要包含头文件<fstream>

文件类型分两类：

文本文件	文件以文本的ASCLL码的形式存储在计算机内
二进制文件	文件以文本的二进制的形式存储在计算机内，用户一般不能读懂

操作文件的三大类：

ofstream	写操作
ifstream	读文件
fstream	读写操作

6.2）文本文件：

6.2.1）写文件：

①包含头文件：#include<fstream>
②创建流对象：ofstream ofs;
③打开文件：ofs.open("文本路径",打开方式);
④写数据：ofs<<"写入的数据";
⑤关闭文件：ofs.close();

文件打开方式：

打开方式
ios::in	为读而打开文件，
ios::out	为写而打开文件，会删除原来的内容
ios::ate	初始位置：文件尾，会删除原来的内容
ios::app	追加方式写文件
ios::trunc	如果文件存在先删除，再创建
ios::binary	二进制方式

注意：文件打开方式可以配合使用，利用|操作符

例：用二进制方式写文件ios::binary| ios::out

6.2.2）读文件：

①包含头文件：#include<fstream>
②创建流对象：ifstream ifs;
③打开文件：ifs.open("文本路径",打开方式);

//打开文件判断是否成功
//ifs.open(...);
if(!ifs.is_open())
{
    cout<<"文本打开失败"<<endl;
    return;
}

④写数据：四种方式读取
⑤关闭文件：ofs.close();

有4种读数据方式：

①

	char buf[1024] = { 0 };
	while (ifs >> buf) {
		cout << buf << endl;
	}

②

	char buf[1024] = { 0 };
	while (ifs .getline(buf,sizeof(buf))) {
		cout << buf << endl;
	}

③

	string buf;
	while (getline(ifs,buf)) {
		cout << buf << endl;
	}

④好像读不到汉字

	char c;
	while ((c=ifs.get())!=EOF) {
		cout << c << endl;
	}

6.3）二进制文件

以二进制的方式对文本进行读写操作

打开方式要指定为ios::binary

6.3.1）写文件

主要利用流对象调用成员函数write

函数原型：ostre write (const char* buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数。

//片段
Person p={"张三",18};
ofs.write((const char*)&P,sizeof(Person));

6.3.2)读文件

主要利用流对象调用成员函数read

函数原型：istream& write (const char* buffer,int len);

参数解释：字符指针buffer指向内存中一段存储空间。len是读写的字节数。

//片段
Person P;
ifs.read((char *)&P,  sizeof(Person));

小黑的尾巴呀

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
【无标题】7 c++基础自用

c++自用，基础简述
复制链接

扫一扫

专栏目录

【无标题】7 c++基础自用

一

1始

1）编程序：

2）注释

3）变量

4）常量

5）关键字

6）标识符命名规则

2数据类型

1）

2）整型

3）sizeof关键字

4）实型（浮点型）

5）字符型

6）转义字符

7）字符串型

8）布尔类型bool

9）数据输入

3运算符

1）作用：运算