C++小小复习一下
类，对象，成员变量，成员函数
特点：面向对象程序设计---因为要创建对象来调用类里面的函数或者成员变量
比如你的对象是一个生物-人：他会有自己的一些属性：身高，体重，性别等，还有一些行为比如：有人惹他，他会骂回去或者打回去，这个骂和打的动作或者行为需要一系列的身体各个机能共同合作才能实现。上面的属性就和成员变量很像，行为就和成员函数很像----需要通过各种的逻辑结构来实现一个功能。
你对象的基因就会实现它的身高的具体实现，是男是女，性别，还有性格特征，行为特征----和类就很像了
那中总结一下：
- 类------基因
- 对象-----你的对象
- 成员变量-----属性
- 成员函数-----行为
成员函数
普通成员函数
- 类内声明
- 类外实现
- 返回值类型 类名::成员函数名(参数表){ 函数体}
内联成员函数
- 隐式声明：在类内部声明和实现
- 显示声明：在类外实现
对象
在声明类的同时直接定义对象
class Score{
public:
void setScore(int m, int f);
void showScore();
private:
int mid_exam;
int fin_exam;
}op1, op2;
声明了类之后，在使用时再定义对象
Score op1, op2;
对象中成员函数的访问
对象名.数据成员名对象名.成员函数名[(参数表)]op1.setScore(89, 99);
op1.showScore();
-
在类的内部所有成员之间都可以通过成员函数直接访问，但是类的外部不能访问对象的私有成员。
-
私有成员只能被类中的成员函数访问，不能在类的外部，通过类的对象进行访问。
-
在定义对象时，若定义的是指向此对象的指针变量，则访问此对象的成员时，不能用“
.”操作符，而应该使用“->“操作符。如
Score op, *sc;
sc = &op;
sc->setScore(99, 100);
op.showScore();
你的对象就可以通过属性和行为引起你的注意和反应-----产生交流
和C不同的一些常用函数
输入输出
cin >> i;
cout << f;定义常量
const
指针常量
const char* pc = "abcd";
该方法不允许改变指针所指的变量，即
pc[3] = ‘x'; 是错误的，
但是，由于pc是一个指向常量的普通指针变量，不是常指针，因此可以改变pc所指的地址，例如
pc = "ervfs";
该语句付给了指针另一个字符串的地址，改变了pc的值。
常量指针
char* const pc = "abcd";
创建一个常指针，一个不能移动的固定指针，可更改内容，如
pc[3] = 'x';
但不能改变地址，如
pc = 'dsff'; 不合法
指向常量的常指针
const char* const pc = "abcd";
内容和地址均不能改变
内联函数inline
特点：
- 减小系统开销
- 不能有复杂控制语句
- 空间换时间
#include <iostream>
using namespace std;
inline double circle(double r) //内联函数
{
double PI = 3.14;
return PI * r * r;
}
int main()
{
for (int i = 1; i <= 3; i++)
cout << "r = " << i << " area = " << circle(i) << endl;
return 0;
}
作用域标识符----::
强制类型转换
int i = 10;
double x = (double)i;
或
int i = 10;
double x = double(i);
new和delete 运算符
在C语言里面是malloc()和free()函数
指针变量名 = new 类型
int *p;
p = new int;
delete 指针变量名
delete p;
-
用运算符new分配的空间，使用结束后应该用也只能用delete显式地释放，否则这部分空间将不能回收而变成死空间。
指针变量名 = new 类型名[下标表达式];
int *p = new int[10];
delete []指针变量名;
delete p;
引用
变量的别名，声明和初始化同步
#include <iostream>
using namespace std;
int main()
{
int i = 10;
int &j = i;
cout << "i = " << i << " j = " << j << endl;
cout << "i的地址为 " << &i << endl;
cout << "j的地址为 " << &j << endl;
return 0;
}
- 指针是通过地址间接访问某个变量，而引用则是通过别名直接访问某个变量。
- 传参
#include <iostream>
using namespace std;
void swap(int &a, int &b)
{
int t = a;
a = b;
b = t;
}
int a[] = {1, 3, 5, 7, 9};
int& index(int i)
{
return a[i];
}
int main()
{
int a = 5, b = 10;
//交换数字a和b
swap(a, b);
cout << "a = " << a << " b = " << b << endl;
cout << index(2) << endl; //等价于输出元素a[2]的值
index(2) = 100; //等价于将a[2]的值赋为100;
cout << index(2) << endl;
return 0;
}
函数重载，重写和隐藏
重载：作用域相同，函数参数不同，函数名相同------同一个类中----二义性
重写：作用域不同，函数参数相同，函数名相同------派生类和基类同名函数用virtual实现多态
隐藏：作用域不同，返回参数不同，函数名相同，函数参数相同----重定义，派生类中同名同参方法代替基类的现象
友元函数-friend
特点：不属于任何类的非成员函数
用途：因为类的私有成员只能通过成员函数来调用，麻烦。而友元函数可以访问类的所有成员
书写规范：在类中声明友元函数时，需要在其函数名前加上关键字friend。此声明可以放在公有部分，也可以放在保护部分和私有部分。友元函数可以定义在类内部，也可以定义在类外部。
定义规范：因为友元函数不是类的成员，所以它不能直接访问对象的数据成员，也不能通过this指针访问对象的数据成员，它必须通过作为入口参数传递进来的对象名（或对象指针、对象引用）来访问该对象的数据成员
- 一个类的成员函数作为另一个类的友元函数时，必须先定义这个类。并且在声明友元函数时，需要加上成员函数所在类的类名；
- 一个函数同时定义为两个类的友元函数
- 将非成员函数声明为友元函数
- 将成员函数声明为友元函数
多态
同一接口的不同表现形式
连编这一概念有关，所谓连编就是把函数名与函数体的程序代码连接在一起的过程。
编译时多态
含义：静态连编就是在编译阶段完成的连编。编译时的多态是通过静态连编来实现的。静态连编时，系统用实参与形参进行匹配，对于同名的重载函数便根据参数上的差异进行区分，然后进行连编，从而实现了多态性。
优点：静态连编要求在程序编译时就知道调用函数的全部信息。因此，这种连编类型的函数调用速度快、效率高
运行时多态
运行时的多态是用动态连编实现的。动态连编时运行阶段完成的，即当程序调用到某一函数名时，才去寻找和连接其程序代码，对面向对象程序设计而言，就是当对象接收到某一消息时，才去寻找和连接相应的方法。
优点：序运行时才能确定调用哪个函数，它降低了程序的运行效率，但增强了程序的灵活性
C一般用静态联编
C++一般用动态，实际是静态连编和动态连编相结合
在C++中，编译时多态性主要是通过函数重载和运算符重载实现的；运行时多态性主要是通过虚函数来实现的。
虚函数---基类中用
可以实现在一个或多个派生类中被重新定义
特点：虚函数在派生类中重新定义时，其函数原型，包括返回类型、函数名、参数个数、参数类型的顺序，都必须与基类中的原型完全相同。
virtual 返回类型 函数名(形参表) {
函数体
}
纯虚函数
virtual 函数类型 函数名(参数表) = 0;抽象类至少有一个纯虚函数
还没写完，要下班了，每天继续。
我的一些小小的谬论，请多多指教