C++语言程序设计

最新推荐文章于 2024-07-02 09:56:13 发布

Nashino

最新推荐文章于 2024-07-02 09:56:13 发布

阅读量4.9k

点赞数 5

文章标签：其他

本文链接：https://blog.csdn.net/xiyuanliofficial/article/details/121886442

版权

第一章绪论:

世界第一台计算机诞生于1946年

计算机系统包括硬件系统和软件系统.

编译程序是将高级语言翻译成中间语言或者汇编语言.

在C++编译过程中，包含预处理过程、编译过程和连接过程，并且这三个过程的顺序不能改变.

编译阶段查出的错误是语法错误，连接时查出的错误称连接错.

源程序在编译过程中可能会出现一些错误信息，在连接过程也可能出现错误信息。

面向对象的软件工程包括分析，设计，编程，测试，维护

编写C++程序设计一般需要经过的几个步骤依次是编辑编译连接运行

源程序:源语言可以是汇编语言，也可以是高级程序设计语言,由源语言编写有待翻译的程序,

目标程序:是源程序通过翻译加工以后所生成的程序,可以用机器语言,汇编语言或其他中间语言表示.

翻译程序有三种：汇编程序，编译程序，解释程序.

汇编程序:将用汇编语言写成的源程序翻译成机器语言形式的目标程序

编译程序:源程序由高级语言所写,经翻译加工生成目标程序,该翻译程序就是编译程序.

解释程序:将高级语言翻译成机器指令,一边翻译一遍执行

面向对象分析(OOA) 面向对象设计(OOD) 面向对象编程(OOP)

负数采用补码表示后，可以使加减法统一为加法运算

*.obj是目标程序文件 *.exe是可执行文件 *.cpp是源程序文件

进制转换:

1.R进制转换十进制:例如22.22二进制转换成十进制为 $2*2^{1}+2*2^{0}+2*2^{-1}+2*2^{-2}$

2.十进制转换成R进制:分为整数和小数,整数使用除R取余法,小数使用乘R取整法.

3.二,八,十六进制相互转换:例如二进制数1111转换成八进制和十六进制时(每三位二进制可以看作一位八进制,每四位二进制可以看作一位十六进制)例如 $1111_{(2)}$ =(001 111)= $17_{(8)}$ $1111_{(2)}$ =(1111)= $F_{(16)}$

二进制数的编码表示:

1.原码:将符号位数字化为0(正)或1(负),数的绝对值与符号一起编码.例如X=+0101011 原码是00101011,X=-0101011 原码是10101011,X称为机器数的真值,对于一个带符号的纯小数,它的原码表示就是把小数点左边一位用作符号位.例如X=+0.1011 原码为0.1011 X=-0.1011 原码为 1.1011.

2.反码:作为求补码的中间码,正数的原码和反码相同,负数的反码符号位和原码相同其余各位取反(0变成1,1变成0).

3.补码:对正数来说原码,补码,反码都相同.对于负数来说,其补码由该数反码末位加1求得.采用补码表示可以解决0的二义性,同时参与算术运算时符号位可以作为数值参与运算无须单独处理,同时减法运算可以转换为加法运算.补码运算的结果仍然是补码.

定点数和浮点数:一个数N用浮点形式表示(即科学计数法)可以写成: $N=M*R^{E}$ ,其中R表示基数(一旦机器定好基数值就无法改变),E表示N的阶码,M表示N的尾数.指数形式0.345E+2表示 $0.345*10^{2}$

非数值信息的表示:ASCII码采用7位二进制,则最多可以表示128个字符,0的ASCII码是48,a的ASCII码是97,A的ASCII码是65.

第二章 C++语言简单程序设计:

C语言之父丹尼斯里奇 C++语言之父本贾尼斯特劳斯特卢普

C++语言标识符构成规则:以大写,小写字母或下划线(_)开始,以大写小写字母,下划线(_),数字0~9组成,不能是C++语言关键字或操作符,区分大小写.

byte(字节) bit(比特) 1字节有8比特也就是8位.sizeof()运算符可以求得长度(单位字节).

常量(const)只能在声明的时候赋值,而在后面不能改变值.对枚举类型按常量处理，在声明时可以赋值，使用时不能在赋值。const 类型变量名 =常量值.

字符和字符串在内存中的存放形式不相同,'a'不等于"a",后者比前者多了\0.

程序中十六进制数表示方法是数开头为0x,八进制数表示方法是数开头0

typedef是用于将一个标识符声明成某个数据类型的别名

函数是C++程序中最小的功能单位。

程序设计中最基本的控制结构包括:顺序,选择,循环.

算术运算符和算术表达式:i++和++i区别在于表达式的值,前者是i一开始的值,后者是i自增后的值.

逗号运算,(表达式1,表达式2)先计算表达式1再计算表达式2最后整个表达式值为表达式2的值.

位运算:1.按位与(&) 例如3&5->00000011&00000101=00000001,相当于每一位分别进行逻辑与操作.

2.按位或(|) 即每一位分别进行逻辑或操作

3.按位异或(^) 每一位进行异或,即对应位相同则为0,对应位不同则为1.

4.按位取反(~) 单目运算符每一位取反 ~025=~(0000000000010101)=1111111111101010

类型显式转换:const_cast,dynamic_cast,reinterpret_cast,static_cast.用法相同例如 const_cast<类型说明符>(表达式)

第三章函数:

内联函数(inline)中不可以含有递归或循环语句。内联函数是一个请求,有时即使不写inline计算机也会自动看作内联函数.

函数原型中的参数名与函数定义中的参数名以及函数调用中的参数名不必一致.

函数直接或间接地调用自身，称为递归调用

在C语言中，声明函数时，括号内为空，表示参数是未知的，只有括号内是void时才表示这个函数没有参数.C语言中如果括号内形参为空，则表示参数是未知的，在C++语言中，这表示没有形参

函数在面向过程的结构化程序设计中是基本单位，在面向对象程序设计中是对功能的抽象.

函数重载:具有相同的函数名,必须(形参个数或者类型不相同),编译器才能匹配调用哪一个函数.

第四章类与对象:

,面向对象程序设计主要特点:抽象,封装,继承和多态.

C++的类就是在结构体的基础上扩充发展而来的。

类的对一组具有相同属性的对象的抽象描述。类的成员,在给出完整定义之前是不能够创建一个对象的.

在类中如果不作特殊说明就都是私有成员(private)

在创建对象时，既要对本类对象成员进行初始化也要对内嵌对象成员进行初始化.

引用是用来给某个变量起个别名，对引用的操作，实质上就是对被引用变量的操作。

析构函数不能有形参.析构函数用来完成对象被删除前后一些清理工作，一个类中可以有多个构造函数，但是只有一个析构函数

~类名(){函数体}//析构函数
类名(形参){函数体}//构造函数
类名(const 类名 引用/*&c*/){函数体}//复制构造函数

没有写构造函数/析构函数，编译器自动调用隐含的构造函数/析构函数.

类的组合就是在一个类里面有另一个类的对象.

创建一个组合类的对象时，不仅它自身的构造函数会被执行，还将调用内嵌对象的构造函数，调用顺序按照内嵌对象在组合类的定义中出现的顺次序。

前向引用声明:

(1)
class Fred; //前向引用声明.
class Barney{
    Fred x;
    //错误:类Fred的定义尚不完善.
};
class Fred{
    Barney y;
};
(2)
class Fred;//前向引用声明.
class Barney{
public:
    ...
    void method(){
        x.yabbaDabbaDo();//错误:Fred类的对象在定义之前被使用.
    }
private:
    Fred &x;//正确:经过前向引用声明,可以声明Fred类的对象的引用或指针.
};
class Fred{
public:
    ...
    void yabbaDabbaDo();
private:
Barney &y;
};

https://blog.csdn.net/soft_zzti/article/details/79811923?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163929559316780357241267%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163929559316780357241267&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-79811923.first_rank_v2_pc_rank_v29&utm_term=UML&spm=1018.2226.3001.4187

*结构体:

struct 结构体名称
{
    公有成员
protected:
    保护型成员
private:
    私有成员
};

*枚举类型:

enum 枚举类型名 {变量值列表};
//初始值从0开始往后一一对应,如果有赋值则从该值开始.
//例如
enum W{yu,i,c=8,w,e};  //yu=0 i=1 w=9 e=10

第五章数据的共享与保护:

https://blog.csdn.net/thklzsj/article/details/100038640?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163929005616780264099031%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163929005616780264099031&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-100038640.first_rank_v2_pc_rank_v29&utm_term=%E6%95%B0%E6%8D%AE%E7%9A%84%E5%85%B1%E4%BA%AB%E5%92%8C%E4%BF%9D%E6%8A%A4&spm=1018.2226.3001.4187

若要在类中加入静态成员(static),则要在类内声明,在类外定义.

类的友元(friend):友元关系提供了不同类或对象的成员函数之间,类的成员函数与一般函数之间进行数据共享的机制.单方面共享.例如A是B的友元类,A中可以访问B的私有和保护成员但是B不能访问A的私有和保护成员.

友元函数:是在类中用关键字friend修饰的非成员函数,在它的函数体内可以通过对象名访问类的私有和保护成员.

编译预处理:所有的预处理指令在程序中都是以"#"来引导.

//项目中常用
#ifndef 标识符
#define 标识符

程序段

#endif

第六章数组指针与字符串:

(22条消息) C语言总结（一维数组、二维数组、字符数组和字符串）_csuft20164442的博客-CSDN博客_c语言二维字符数组

(22条消息) 深入理解C语言指针_ZackSock的博客-CSDN博客_深入理解c指针

动态内存分配:在c++程序中建立和删除堆对象使用两个运算符,new和delete.

new 数据类型 (初始化参数列表);
int *p=new int(2);
//对于基本数据类型,如果不希望在分配内存后设定初值,可以省略括号,例如:
int *p=new int;
//如果保留括号,但括号中不写任何数值,则表示用0对该对象初始化,例如:
int *p=new int();
//删除
delete 指针名;


//可以创建数组类型
new 类型名[数组长度]
//删除
delete [] 指针名;

对于创建动态数组后面[]可以加(),如果不加对每个元素初始化时与new T时相同,加了()就与new T()时相同.

用vector创建数组对象:

//引入头文件
#include<vector>
vector<元素类型>数组对象名(数组长度);
//初值也可以自己指定,但是只能为所有元素赋相同的值
vector<元素类型>数组对象名(数组长度,元素初值);

vector定义的数组对象有一个重要成员函数size(),它会返回数组的大小.

getline函数的使用

//如果想使用字符串来存输入的东西
#include <string>
string i;
getline(cin,i);//默认判断是换行也可以自定义
getline(cin,i,字符);

第七章类的继承:

https://blog.csdn.net/weixin_42193674/article/details/81050687?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163929859416780274173869%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163929859416780274173869&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-81050687.first_rank_v2_pc_rank_v29&utm_term=%E7%B1%BB%E7%9A%84%E7%BB%A7%E6%89%BF&spm=1018.2226.3001.4187https://blog.csdn.net/weixin_42193674/article/details/81050687?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522163929859416780274173869%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=163929859416780274173869&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-81050687.first_rank_v2_pc_rank_v29&utm_term=%E7%B1%BB%E7%9A%84%E7%BB%A7%E6%89%BF&spm=1018.2226.3001.4187类型兼容规则:1.派生类的对象可以隐含转换为基类对象.2.派生类的对象可以初始化基类的引用.3.派生类的指针可以隐含转换为基类的指针.在替代后,派生类的对象就可以作为基类的对象使用,但只能使用基类继承的成员.

派生类的构造和析构函数:构造派生类对象时,就要对基类的成员对象和新增成员对象进行初始化.对基类初始化时,需要调用基类带有形参表的构造函数时,派生类就必须声明构造函数.

#include<iostream>
uisng namespace std;
class Base1{ //基类Base1,构造函数有参数.
public:
    Base1 (int i){cout<<"Constructing Base1"<<i<<endl;}
};
class Base2 {//基类Base2 构造函数有参数.
public:
    Base2(int j){cout<<"Constructing Base2"<<j<<endl;}
};
class Base3{//基类Base3 构造函数无参数
public:
    Base3(){cout<<"Constructing Base3"<<endl;}
};
class Derived:public Base2,public Base1,public Base3{
//派生新类Derived,注意基类名的顺序
public:
    Derived(int a,int b,int c,int d):Base1(a),member2(d),member1(c),Base2(b){}
    //注意基类名的个数和顺序,注意成员对象名的个数和顺序
private:
    Base1 member1;
    Base2 member2;
    Base3 member3;
};
int main(){
    Derived obj(1,2,3,4);
    return 0;
}

运行结果:

Constructing Base2 2
Constructing Base1 1
Constructing Base3 *
Constructing Base1 3
Constructing Base2 4
Constructing Base3 *

(22条消息) C++虚基类的作用、用法和意义_Leonard_wang的专栏-CSDN博客_虚基类的作用

第八章多态性:(往后几章简略写)

析构函数无参数，因此不能够进行重载。

多态性可以分为:重载多态,强制多态,包含多态和参数多态.

运算符重载规则:

C++除了类属关系运算符"."和成员指针运算符".*"和作用域分辨符"::"和三目运算符"? :"不能重载以外其他都可以.
重载之后运算符的优先级和结合性都不变.
不能改变原运算符的操作对象个数,同时至少有一个操作对象时自定义类型.

//一般语法
返回类型 类名::operator运算符(形参表)
{
    函数体
}
//运算符重载为非成员函数的一般语法形式:
返回类型 operator运算符(形参表)
{
    函数体
}

关于前置和后置:

//前置++和--都一样这里用前置++:++a
返回类型 类名::operator++()
{
    函数体
}
//后置++
返回类型 类名::operator++(int)
{
    函数体
}

<<和>>的重载

ostream & operator<<(ostream &out,const Complex &c){
    out<<c.real<<c.imag;
    return out;
}//>>同理 Complex是自定义的类

多态:编译时的多态和运行时的多态,绑定是指计算机程序自身彼此关联的过程,就是把一条消息和一个对象的方法相结合的过程.

绑定工作在编译连接阶段完成叫作静态绑定,在程序运行的阶段完成叫作动态绑定(虚函数是动态绑定,而重载,强制,参数多态都是静态,例如类型转换,模板重载都是静态绑定).

(虚函数,抽象类,纯虚函数跳过)

抽象类不能实例化，即不能定义其对象.

构造函数不能定义成虚函数构造，原因是:1 构造一个对象的时候，必须知道对象的实际类型，而虚函数行为是在运行期间确定实际类型的。如果将构造函数定义为虚函数，在构造一个对象时，会导致编译器无法知道对象的实际类型，是该类本身，还是该类的一个派生类，或是更深层次的派生类。

通过基类指针删除派生类对象时调用的是基类的析构函数，只有将基类的析构函数声明为虚函数，才能调用派生类的析构函数

使用带有默认形参的重载函数，在调用时一定要注意和其他重载函数区分开，避免二义性。例如定义Point类构造函数时，可以有默认形参的构造函数Point(int x=0,int y=0);和没有形参的构造函数Point();能够实现重载，但是调用时不可以写成Point p;这样就会出现二义性，不知道到底调用哪个构造函数。

当第一个操作数是不可以更改的类型时不可以重载为类成员函数。例如<<运算符，第一个操作数的类型是ostream类型，是标准库的类型，无法向其中添加成员函数，那么只可以用非成员函数的形式进行重载。

虚函数必须是非静态的成员函数，这样才能通过基类指针或引用调用定义为虚函数的函数，从而实现多态性。

基类中的虚函数和其派生类中的虚函数必须具有相同的参数个数和类型，才能实现多态性

C++的流库预定义了4个流:cin,cout,clog,cerr

第九章模板与群体数据:

函数模板:

template <模板参数表>
类型名 函数名(参数表)
{
    函数体的定义
}

所有函数模板的定义都是用关键字template开始的,该关键字之后是使用尖括号<>括起来的"模板参数表",模板参数表可以包含以下几类:

class(或typename)标识符,指明可以接收一个类型参数,这些类型参数代表的是类型,可以预定义类型或自定义类型.
类型说明符标识符,指明可以接收一个由"类型说明符"所规定类型的常量作为参数;
template<参数表>class 标识符,指明可以接收一个类模板名作为参数;

//例如
template<class T>
void fun(T &a,T &b)//两个数交换的函数模板
{
    T y=a;
    a=b;
    b=y;
}
//然后可以在程序里实现即:
int main()
{
    int a=1,b=2;
    fun(a,b);
    cout<<a<<b;
    return 0;
}

(跳过群体数据)

第十一章流类库的输入与输出(简略):

二进制文件的写操作用成员函数write()。

#include<fstring>//头文件 

ofstream o("文件名");//o可以任意命名,使用方法和cout相同,不过是输出到文件
ifstream i("文件名");//i可以任意命名,使用方法和cin相同,不过是将文件的东西输入

第十二章异常处理:

只需要会使用throw try catch即可.

异常的处理会与其最先匹配到的catch子句处理，而不是最近.C++运行系统可以处理程序没有处理的异常

C++引入了关键字throw和try 、catch；用于进行异常处理。其中异常的引发为throw，异常的捕获为try catch

异常（Exception）是程序运行过程中，由于环境变化、用户操作失误以及其它方面的原因而产生的运行时不正常的情况，是可以预料但不能避免的。是一种对象

异常不是错误，以消息形式传递，catch不能捕获错误，catch捕获异常。C++不能处理所有异常，仅能处理已经定义的异常类型。

//throw 表达式语法:
throw 表达式;
//try块语法:
try
    复合语句
catch(异常声明)
    复合语句
catch(异常声明)
    复合语句
...

如果在保护段执行期间没有引起异常那么跟在try块后的catch语句就不执行.

程序执行到一个throw表达式时,一个异常对象会被创建.

如果始终没有找到与被抛出异常匹配的catch子句,最终main函数会结束执行,则运行库函数terminate将自动调用,默认功能为终止程序.

异常接口声明:

void fun() throw(A,B,C,D);
//表明函数fun()能够且只能够抛出类型ABCD及其子类型的异常
void fun();
//可以抛出任何类型的异常;
void fun() throw();
//不抛出任何类型的异常.此时unexpected函数被调用然后调用terminate终止程序.