C++复习

第一章C++概述

C++是一种面向对象的编程语言，是c语言的扩展。用于游戏引擎、嵌入式系统等领域，可以在几乎所有操作系统上运行

Java是一种面向对象的编程语言，具有跨平台性和安全性等特点。用于开发Web应用、移动应用、游戏等领域，是完全跨平台的语言，可以在任何支持Java虚拟机（JVM）的操作系统上运行

C#是微软推出的一种面向对象的编程语言，专门用于.NET平台，结合了C++的功能和Java是简洁性，。用于开发Windows桌面应用、Web应用、游戏开发等。最初是为Windows开发的，随着.NET Core和.NET 5的推出，变得更加跨平台性

#include<Iostream.h>

cin>>a>>b

命名空间

using namespace std;

输入输出

cout<<"Enter an integer,float,and string:";

cin>>i>>f>>s;

cout<<"Here's your data:"<<i<<' '<<f<<endl<<s<<'\n';

在输入数据时，如果有多个数据，各个数据之间用空格(回车或Tab)分隔，输入Enter键结束。 在析取运算符>>后面只能出现变量名，这些变量应该是系统预定义的简单数据类型，否则将出现错误。

const修饰符

#define PI 3.1415926

const float PI=3.1415926;

指针常量（指向常量的指针）const char* pc

char s[]="Gorm";

const char* pc=s;//指针pc所指向的字符串为常量

pc[3]="o";//error

pc=p;//ok

常量指针（指针本身为常量）char*const pc

char s[]="Gorm";

char*const pc=s;//常指针

pc[3]="o";//ok  可以改变常指针所指向的对象

pc=p;//error  不能改变常量指针的值

指向常量的常量指针

指针本身和指向的对象都为常量

char s[ ] = “Gorm”;

const char *const cpc = s; // 指向常量的常指针

cpc[3] = ´a´;  // error: cpc 不能修改常量

cpc = p;  // error: cpc 不能改变常量指针的值

const int * ptr和int const * ptr意义相同

函数

内联函数

inline
编译器直接将实现该函数的目标代码插入到调用该函数的语句之处，从而消除函数调用时的时间开销，提高运行速度。

利用内嵌函数减少了调用普通函数时的压栈和弹栈操作，从而提高程序的运行速度。 这是一种用空间换时间的措施，通常一些短小的函数适合作为内联函数。

内联函数可以是类的成员函数，直接在类的内部给出成员函数的定义，该函数自动成为内联函数，此时无需使用关键字inline说明

带缺省参数的函数

void  DrawCircle(int x,int y,int r=10);

DrawCircle(50,20);

DrawCircle(50,100,30);

函数名重载

int abs(int n);

long abs(long n);

double abs(double n);

new和delete

int main( )
{
  int *p;
  p=new int;  //为整数分配动态内存空间
  if(!p) {
    	cout<<"Allocation error\n";
   	return 1; }
*p=1000;
  cout<<"Here is integer at p: "<<*p<<"\n";
  delete p; // 释放new分配的动态内存空间
  return 0;
}

注意：用new申请的动态内存必须用delete释放

引用（已存在变量的别名，公用内存单元）

#include "iostream"
using namespace std;
int main()
{  int m;
   int &n=m;  //变量n为m的引用别名
   m=30;
   cout<<"m="<<m<<"n="<<n<<"\n";
   n=80;
   cout<<"m="<<m<<"n="<<n<<"\n";
   cout<<"m地址是:"<<&m<<endl;
   cout<<"n地址是:"<<&n<<endl;
   return 0;
}

值传递（单向）

地址传递（双向）

---

第二章 类和对象

类是对一组具有 共同属性特征 和 行为特征 的实体 ( 对象 ) 的抽象，它将 相关数据 及对这

些 数据的操作 组合在一起。

类 (class) 是面向对象系统中最基本的组成元 素，是一种自定义数据类型，不占内存空间。

在 C++ 中， 类 是一些具有 相同属性 和 行为 的对象的抽象。

对象是某个 特定类 所描述的 实例 ，类实例化之 后才是一个确定的物体占内存空间
类是对象的抽象，而对象是类的实例

在 缺省情况下 ，结构中的成员 是私有的。

成员函数在类体内定义
class Student
{
private:
int number;
public:
void print( )
{
cout<<”number: ” <<number<<’\n’;
}
};

成员函数在类体外定义
class Student
{
private:
int number;
public:
void print();
};
void Student::print( ) //作用域解析运算符
{
cout<<”number: ” <<number<<’\n’;
}

构造函数

为对象进行 初始化 ， 构造函数的 函数名与类名 相同 。

class Date {
int day, month, year;
Date(int dd, int mm, int yy)
{
day = dd;
month = mm;
year = yy;
} 
};

//
class Date {
int day, month, year;
Date(int dd, int mm, int yy) ; 
}; //构造函数名与类名相同
void Date::Date(int dd, int mm, int yy)
{
day = dd;
month = mm;
year = yy;
}

◼ 构造函数可以有任一类型的参数，但 不能具有返 回类型 。

◼ 构造函数与其它函数一样可以 重载 也可以 有缺省 参数 。

class complex{
private:
double real;
double image;
public:
void complex(double r=0.0,double i=0.0)
{ real=r; image=i; }
double realcomplex()
{ return real; }
…;
};

◼ 当定义（实例化）一个对象时， 系统自动调用 构 造函数进行初始化。

析构函数

释放构造函数所动态 申请的内存空间 。

◼ 析构函数的名称与其 类名称相同 ，并在名称的 前边加 ~

组合类和对象成员的初始化 

当一个类的对象作为另一个类的成员时，称为该类的对象成员

类的对象成员初始化
#include <iostream>
using namespace std;
class inner_class{
int x;
public:
inner_class(int z){x=z;}
void write(){ cout<<x<<endl;}
};


class outer_class{ // outer_class类的声明
int y;
inner_class x;
inner_class r;
public:
outer_class(int z);
void write(){cout<<y<<endl;}
void write_inner_x()
{ x.inner_class::write();}
void write_inner_r()
{r.inner_class::write();}
};
outer_class::outer_class(int z):x(20),r(-36)
{ y=z;}
int main()
{
outer_class obj(10);
obj.write_inner_x();
obj.write_inner_r();
obj.write();
return 0;
}

常成员函数 ，不更新对象的成员数据（只读函数）

常对象，必须初始化且不能被更新，只能调用它的常成员函数

第四章进一步学习类和对象

对象数组

#include <iostream>
using namespace std;
class samp{
int a,b;
public:
samp(int n,int m) { a=n; b=m; }
int get_a( ) { return a; }
int get_b( ) { return b; }
};
int main()
{
samp ob[4][2]={
samp(1,2),samp(3,4),
samp(5,6),samp(7,8),
samp(9,10),samp(11,12),
samp(13,14),samp(15,16),
};

指向对象的指针

指向存放该对象的地址

int main( )
{ Circle c1(3), *pc; 
//pc为指向Circle类对象的指针
pc=&c1; 
//将对象c1的地址赋给对象指针pc，使其指向圆形对象c1
cout<<c1.GetArea( )<<endl;
//通过对象名访问对象的方法
cout<<pc->GetArea( )<<endl;
//通过对象指针访问对象的方法
return 0;
}

int main( )
{ Circle c1(3), *pc; 
pc=&c1;
cout<<pc->GetArea( )<<endl; //ok
Circle *c2=new Circle(3);
cout<< c2->GetArea( )<<endl;//ok
Circle *c3;
cout<< c3->GetArea( )<<endl;//error
return 0;}

this指针

void Student ::Set( Date* const this , int number1, string name1, float

score1)

{

this- > number = number1;

strcmp( this- > name,name1);

this- > score = score1;

}

（隐含指针）

对象的赋值

#include <iostream>
using namespace std;
class Rectangle {
int L, W;
public:
Rectangle(int i, int j) { L = i, W = j; }
void show_Rect();
};
void Rectangle::show_Rect()
{
cout << "Length is " << L << '\n';
cout << "Width is " << W << '\n';
}
int main()
{
Rectangle rect1(10, 20), rect2(0, 0);
rect1.show_Rect();
rect2.show_Rect();
rect2 = rect1; // 将矩形对象rect1赋值给矩形对象rect2
rect1.show_Rect();
rect2.show_Rect();
return 0;
}

对象作为函数参数

传值

class Square {
int side;
public:
void set(int x) { side = x; }
void out() { cout << side << "\n"; }
};
void f(Square x) //采用传值方式将实际对象传送给临时对象x
{
x.out(); // 输出正方形Square1类对象x的边长为10
x.set(100); // 这仅仅修改了临时对象x的边长
x.out(); // 输出正方形Square1类对象x的边长为100
}
int main()
{ Square s;
s.set(10);
f(s);
s.out();
// 输出正方形对象s的边长仍然为10，边长没有改变
return 0;}

传地址

class Square {
int side;
public:
void set(int x) { side = x; }
void out() { cout << side << "\n"; }
};
void f(Square &x) //对象的引用作为函数的参数
{
x.out(); // 输出正方形对象x的边长为10
x.set(100); //这实际上就是对作为实际参数的对象s
的修改
x.out(); // 输出正方形对象x的边长为100
}
int main()
{
Square s;
s.set(10);
f(s); //传送对象s的引用给x，x和s代表同一个对象
s.out(); //输出正方形对象s的边长为100，边长改变
了
return 0;
}

函数返回对象

class myString
{
private:
char s[80];
public:
void print(){cout<<s<<endl;}
void set(char*str)
{strcpy(s,str);} 
}
myString input() // 函数的返回类型为myString
{
char instr[80];
myString str; //创建了一个局部对象str
cout << "Enter a string: ";
cin >> instr;
str.set(instr);
return str; // 返回一个myString类型的对象
}
int main()
{
myString ob;
// 将返回的对象复制给对象ob
ob = input();
ob.print();
return 0;
}

类的静态成员

替代全局变量

一个类的 静态数据成员 为该类 所有对象共用 ， 不管我们创建了这个类的多少对象，其静态 数据成员在内存中 只有一份拷贝 。

static

类内声明、类外初始化

class People {
private:
static int count;
int age;
char *name;
public:
static int totalAge;
People (int old, char *string);
…
};
#include <iostream>
int People::count=0;
int People::totalAge=0;
int main( )
{ People member1(32, “Smith”);
People member2(18, “John”);
…
}

静态成员函数

class Student {
static int count;
static float sum;
public:
static void init( ) {
Student::count=0;
Student::sum =0;
}
static float average( ); //静态成员函数的声明
};
//类外定义
float Student::average( ) 
{
cout<<"sum is 
"<<sum<<"\tcount is 
"<<count<<endl;
cout<<"average is 
"<<sum/count<<endl;
return sum/count;
}

类的友元friend

友元的作用：使得非成员函数访问类的私有成员和受保护成员

非成员函数作为友元函数

#include <iostream.h>
#include <math.h>
class Point
{ public:
Point(double xi, double yi) {X=xi; Y=yi; }
double GetX() {return X;}
double GetY() {return Y;}
friend double Distance( Point &a, Point &b);
private:
double X, Y;
};
double Distance( Point& a, Point& b)
{
double dx=a.X-b.X;              //访问对象中的成员必须通过对象名
double dy=a.Y-b.Y;
return sqrt(dx*dx+dy*dy);
}
int main()
{ Point p1(3.0, 5.0), p2(4.0, 6.0);
double d=Distance(p1, p2);
cout<<"The distance is "<<d<<endl;
return 0;
}

成员函数作为友元函数

#include <iostream.h>
#include <math.h>
class Point1
{ public:
Point(double xi, double yi) {X=xi; Y=yi; }
double GetX() {return X;}
double GetY() {return Y;}
friend double Point2 ::Distance2( Point1& a, 
Point1& b);
private:
double X, Y;
};
class Point2
{
public:
double Distance2( Point1 &a, Point1 &b);
}；
double Point2 ::Distance2( Point1& a, Point1& b)
{
double dx=a.X-b.X;
double dy=a.Y-b.Y;
return sqrt(dx*dx+dy*dy);
}
int main()
{ Point1 p1(3.0, 5.0), p2(4.0, 6.0);
Point2 p3;
double d=p3.Distance2(p1, p2);
cout<<"The distance is "<<d<<endl;
return 0;
}

第六章 继承性：派生类

派生类

继承是为了重用已有的程序源代码

①被继承的类称为 基类 ( 或父类 ) ;

②新产生的类称为 派生类 ( 或子类 ) ;

③派生类拥有基类的特性称作 继承 ;

④由基类产生派生类的过程称为 派生 ;

➢ 吸收基类成员；

➢ 对基类成员的改造；

➢ 添加派生类的新成员。

class Student{
int number;
string name;
float score;
public:
Student(int number1, string name1, float 
score1);
void modify(float score1);
void print( );
};

class Ustudent : public Student
{
string major; //专业
public:
Ustudent(int number1, string name1,
float score1, string major1);
void print( );
};

class Pgraduate: public Ustudent
{
string tutor; //导师
public:
Pgraduate(int number1, string name1,
float score1, string major1, string 
tutor1);
void print( );
};

单继承

每一个 派生类 都有 且仅有一个 基类

由于派生类自动、隐含地拥有基类的 数据成 员和函数成员 。

派生类通过 继承基类 中现有的数据成员和函 数成员，并对其进行 覆盖或改写

派生类的构造函数和析构函数

#include <iostream>
using namespace std;
class point{
char c;
public:
point(char ch){c=ch;}
void DrawPoint(){cout<<c;}
};
class line:public point{
int length;
public:
line(char ch,int i):point(ch){ length=i; }
void DrawLine()
{
length=(length<0?0:(length>80?80:length
));
for(int i=0;i<length;i++)
DrawPoint();
cout<<endl;
} };
int main( )
{
line my_line('*',30);
my_line.DrawLine();
return 0;
}

多重继承

class point{
char c;
public:
point(char ch){c=ch;}
void DrawPoint(){cout<<c;}
};
class line:public point{
int length;
public:
line(char ch,int i):point(ch){ length=i; }
void DrawLine()
{
………
}};
class rectangle : public lin