#include<iostream.h>

using name std;

void main ()

{ double r, girth, area ;

const double PI = 3.1415 ;

cout << "Please input radius:\n" ; //操作符重载

cin >> r ;  //输入

girth = 2 * PI * r ;

area = PI * r * r ;

cout << "radius = " << r << endl ;

cout << "girth = " << girth << endl ;

cout << "area = " << area << endl ;

}

using name std;

class Circle

{  double radius ; //成员变量

public : //类的訪问控制

void Set_Radius( double r ) { radius = r ; } //成员函数

double Get_Radius()  { return  radius ; } //通过成员函数设置成员变量

double Get_Girth()     { return  2 * 3.14f * radius ; } //通过成员函数获取成员变量

double Get_Area()     { return  3.14f * radius * radius ; }

} ;

void main()

{

Circle A, B ; //用类定义对象

A.Set_Radius( 6.23 ) ; //类的调用

cout << "A.Radius = " << A.Get_Radius() << endl ;

cout << "A.Girth = " << A.Get_Girth() << endl ;

cout << "A.Area = " << A.Get_Area() << endl ;

B.Set_Radius( 10.5 ) ;

cout << "B.radius = " << B.Get_Radius() << endl ;

cout << "B.Girth=" << B.Get_Girth() << endl ;

cout << "B.Area = " << B.Get_Area() << endl ;

}

#include<iostream>

using namespace std;//c++的命名空间

class circle

{

public:

double r;

double pi = 3.1415926;

double area = pi*r*r;

};

int main()

{

circle pi;

cout << "请输入area" << endl;

cin >> pi.r;

cout << pi.area << endl;  //乱码

system("pause");

return 0;

}

没有深思熟虑的设计过程

使用时存在非常多“灰色地带”

残留量过多低级语言的特征

直接利用指针进行内存操作

终于程序运行效率的高效

C语言 + 面向对象方法论===》Objective C /C++

C++是C语言的加强。是一种更好的C语言

C++是以C语言为基础的。而且全然兼容C语言的特性

学习C++能够接触到很多其它的软件设计方法，并带来很多其它的机会。

1）  C++是一种更强大的C，通过学习C++可以掌握很多其它的软件设计方法

2）  C++是Java/C#/D等现代开发语言的基础，学习C++后可以高速掌握这些语言

3）C++是各大知名软件企业挑选人才的标准之中的一个

在C++中。名称（name）能够是符号常量、变量、宏、函数、结构、枚举、类和对象等等。为了避免，在大规模程序的设计中，以及在程序猿使用各种各样的C++库时，这些标识符的命名发生冲突。

标准C++引入了keywordnamespace（命名空间/名字空间/名称空间/名域）。能够更好地控制标识符的作用域。

*/

std是c++标准命名空间，c++标准程序库中的全部标识符都被定义在std中，比方标准库中的类iostream、vector

等都定义在该命名空间中，使用时要加上using声明(using namespace std)  或using指示(如std::string、

std::vector<int>).

*/

C中的命名空间

在C语言中仅仅有一个全局作用域

C语言中全部的全局标识符共享同一个作用域

标识符之间可能发生冲突

C++中提出了命名空间的概念

命名空间将全局作用域分成不同的部分

不同命名空间中的标识符能够同名而不会发生冲突

命名空间能够相互嵌套

全局作用域也叫默认命名空间

*/

C++命名空间的定义：

namespace name {  …  }

*/

C++命名空间的使用：

使用整个命名空间：using namespace name;

使用命名空间中的变量：using name::variable;

使用默认命名空间中的变量：::variable

默认情况下能够直接使用默 认命名空间中的全部标识符

*/

{

int a = 0;

}

namespace NameSpaceB

{

int a = 1;

namespace NameSpaceC

{

struct Teacher

{

char name[10];

int age;

};

}

}

int main()

{

using namespace NameSpaceA;

using NameSpaceB::NameSpaceC::Teacher;

printf("a = %d\n", a);

printf("a = %d\n", NameSpaceB::a);

NameSpaceB::NameSpaceC::Teacher t2

Teacher t1 = {"aaa", 3};

printf("t1.name = %s\n", t1.name);

printf("t1.age = %d\n", t1.age);

system("pause");

return 0;

}

using namespace std;

//C语言中的变量都必须在作用域開始的位置定义！

。

//C++中更强调语言的“有用性”，全部的变量都能够在须要使用时再定义。

int main11()

{

int i = 0;

printf("ddd");

int k;

system("pause");

return 0;

}

//在c语言中 register修饰的变量 不能取地址，可是在c++里面做了内容

/*

//1

registerkeyword的变化

registerkeyword请求“编译器”将局部变量存储于寄存器中

C语言中无法取得register变量地址

在C++中依旧支持registerkeyword

C++编译器有自己的优化方式，不使用register也可能做优化

C++中能够取得register变量的地址

//2

C++编译器发现程序中须要取register变量的地址时，register对变量的声明变得无效。

//3

早期C语言编译器不会对代码进行优化。因此register变量是一个非常好的补充。

*/

{

register int a = 0;

printf("&a = %x\n", &a);

system("pause");

return 0;

}

在C语言中，反复定义多个同名的全局变量是合法的

在C++中，不同意定义多个同名的全局变量

C语言中多个同名的全局变量终于会被链接到全局数据区的同一个地址空间上

int g_var;

int g_var = 1;

C++直接拒绝这样的二义性的做法。

*/

{

printf("g_var = %d\n", g_var);

return 0;

}

C语言的struct定义了一组变量的集合，C编译器并不觉得这是一种新的类型

C++中的struct是一个新类型的定义声明

{

char name[100];

int age;

};

int main(int argc, char *argv[])

{

Student s1 = {"wang", 1};

Student s2 = {"wang2", 2};

return 0;

}

C++中全部的变量和函数都必须有类型

C语言中的默认类型在C++中是不合法的

函数f的返回值是什么类型，參数又是什么类型？

函数g能够接受多少个參数？

*/

//更换成.cpp试试

f(i)

{

printf("i = %d\n", i);

}

g()

{

return 5;

}

int main(int argc, char *argv[])

{

f(10);

printf("g() = %d\n", g(1, 2, 3, 4, 5));

getchar();

return 0;

}

C++中的布尔类型

C++在C语言的基本类型系统之上添加了bool

C++中的bool可取的值仅仅有true和false

理论上bool仅仅占用一个字节，

假设多个bool变量定义在一起。可能会各占一个bit。这取决于编译器的实现

true代表真值，编译器内部用1来表示

false代表非真值，编译器内部用0来表示

bool类型仅仅有true（非0）和false（0）两个值

C++编译器会在赋值时将非0值转换为true，0值转换为false

*/

{

int a;

bool b = true;

printf("b = %d, sizeof(b) = %d\n", b, sizeof(b));

b = 4;

a = b;

printf("a = %d, b = %d\n", a, b);

b = -4;

a = b;

printf("a = %d, b = %d\n", a, b);

a = 10;

b = a;

printf("a = %d, b = %d\n", a, b);

b = 0;

printf("b = %d\n", b);

system("pause");

return 0;

}

{

int a = 10;

int b = 20;

//返回一个最小数 而且给最小数赋值成3

//三目运算符是一个表达式 。表达式不可能做左值

(a < b ?

a : b )= 30;

printf("a = %d, b = %d\n", a, b);

system("pause");

return 0;

}

{

const int a;

int const b;

const int *c;

int * const d;

const int * const e ;

return 0;

}

Int func1(const )

0基础理解：const是定义常量==》const意味着仅仅读

//第一个第二个意思一样 代表一个常整形数

//第三个 c是一个指向常整形数的指针(所指向的内存数据不能被改动，可是本身能够改动)

//第四个 d 常指针（指针变量不能被改动。可是它所指向内存空间能够被改动）

//第五个 e一个指向常整形的常指针（指针和它所指向的内存空间，均不能被改动）

//合理的利用const，

//1指针做函数參数。能够有效的提高代码可读性，降低bug。

//2清楚的分清參数的输入和输出特性

Const改动形參的时候。在利用形參不能改动指针所向的内存空间

{

const int a = 10;

int *p = (int*)&a;

printf("a===>%d\n", a);

*p = 11;

printf("a===>%d\n", a);

printf("Hello......\n");

return 0;

}

C++编译器对const常量的处理

当碰见常量声明时。在符号表中放入常量 =è问题：那有怎样解释取地址

编译过程中若发现使用常量则直接以符号表中的值替换

编译过程中若发现对const使用了extern或者&操作符。则给相应的常量分配存储空间（兼容C）

？联想： int &a = 1(err) & const int &a = 10(ok)?

C++编译器尽管可能为const常量分配空间。但不会使用其存储空间中的值。

C语言中的const变量

C语言中const变量是仅仅读变量，有自己的存储空间

C++中的const常量

可能分配存储空间,也可能不分配存储空间

当const常量为全局，而且须要在其他文件里使用

当使用&操作符取const常量的地址

//#define N 10

int main()

{

const int a = 1;

const int b = 2;

int array[a + b ] = {0};

int i = 0;

for(i=0; i<(a+b); i++)

{

printf("array[%d] = %d\n", i, array[i]);

}

getchar();

return 0;

}

C++中的const常量类似于宏定义

const int c = 5; ≈ #define c 5

C++中的const常量与宏定义不同

const常量是由编译器处理的，提供类型检查和作用域检查

宏定义由预处理器处理，单纯的文本替换

//在func1中定义的b，在func2中能使用吗？

void fun1()

{

#define a 10

const int b = 20;

//#undef a  # undef

}

void fun2()

{

printf("a = %d\n", a);

//printf("b = %d\n", b);

}

int main()

{

fun1();

fun2();

return 0;

}

{

int a = 10; //c编译器分配4个字节内存。。。a内存空间的别名

int &b = a;  //b就是a的别名。

。。

a =11; //直接赋值

{

int *p = &a;

*p = 12;

printf("a %d \n",a);

}

b  = 14;

printf("a:%d b:%d", a, b);

system("pause");

}

int main()

{

int a = 0;

int &b = a; //int * const b = &a

b = 11;  //*b = 11;

return 0;

}

引用作为函数參数声明时不进行初始化

struct Teacher

{

char name[64];

int age ;

};

void printfT(Teacher *pT)

{

cout<<pT->age<<endl;

}

//pT是t1的别名 ,相当于改动了t1

void printfT2(Teacher &pT)

{

//cout<<pT.age<<endl;

pT.age = 33;

}

//pT和t1的是两个不同的变量

void printfT3(Teacher pT)

{

cout<<pT.age<<endl;

pT.age = 45; //仅仅会改动pT变量 ,不会改动t1变量

}

void main()

{

Teacher t1;

t1.age = 35;

printfT(&t1);

printfT2(t1); //pT是t1的别名

printf("t1.age:%d \n", t1.age); //33

printfT3(t1) ;// pT是形參 ,t1 copy一份数据 给pT     //---> pT = t1

printf("t1.age:%d \n", t1.age); //35

cout<<"hello..."<<endl;

system("pause");

return ;

}

2）引用相对于指针来说具有更好的可读性和有用性

{

int a = 10;

int &b = a;

//b是a的别名。请问c++编译器后面做了什么工作？

b = 11;

cout<<"b--->"<<a<<endl;

printf("a:%d\n", a);

printf("b:%d\n", b);

printf("&a:%d\n", &a);

printf("&b:%d\n", &b);  //请思考：对同一内存空间能够取好几个名字吗？

system("pause");

return 0;

}

int &a;

int &b;

};

int main()

{

printf("sizeof(Teacher) %d\n",sizeof(Teacer));

system("pause");

return 0;

}

char *const p

{

int a;

a = 10;

return a;

}

//基础类型a返回的时候。也会有一个副本

int& getAA2()

{

int a;

a = 10;

return a;

}

int* getAA3()

{

int a;

a = 10;

return &a;

}

int j()

{

static int a = 10;

a ++;

printf("a:%d \n", a);

return a;

}

int& j1()

{

static int a = 10;

a ++;

printf("a:%d \n", a);

return a;

}

int *j2()

{

static int a = 10;

a ++;

printf("a:%d \n", a);

return &a;

}

void main22()

{

// j()的运算结果是一个数值，没有内存地址。不能当左值。

。

。

。。

//11 = 100;

//*(a>b?&a:&b) = 111;

//当被调用的函数当左值的时候。必须返回一个引用。。。

。

。

j1() = 100; //编译器帮我们打造了环境

j1();

*(j2()) = 200; //相当于我们程序猿手工的打造 做左值的条件

j2();

system("pause");

}

{

*p = 100;

return *p;

}

int&  g2(int *p) //

{

*p = 100;

return *p;

}

//当我们使用引用语法的时候 ，我们不去关心编译器引用是怎么做的

//当我们分析乱码这样的现象的时候，我们才去考虑c++编译器是怎么做的。

。

。。

void main23()

{

int a1 = 10;

a1 = g2(&a1);

int &a2 = g2(&a1); //用引用去接受函数的返回值，是不是乱码，关键是看返回的内存空间是不是被编译器回收了。。。。

printf("a1:%d \n", a1);

printf("a2:%d \n", a2);

system("pause");

}

{

char name[64];

int age;

};

//假设返回引用不是基础类型，是一个类，那么情况很赋值。。涉及到copy构造函数和=操作重载，抛砖。。。。

struct Teachar & OpTeacher(struct Teachar &t1)

{

}

using namespace std;

struct Teacher

{

char name[64];

int age;

};

int getTe(Teacher **myp )

{

Teacher *p = (Teacher *)malloc(sizeof(Teacher));

if (p ==NULL)

{

return -1;

}

memset(p, 0, sizeof(Teacher));

p->age = 33;

*myp  = p; //

return 0;

}

//指针的引用而已

int getTe2(Teacher*  &myp)

{

myp = (Teacher *)malloc(sizeof(Teacher));

myp->age = 34;

return 0;

}

void main333()

{

Teacher *p = NULL;

//getTe(&p);

getTe2(p);

printf("age:%d \n", p->age);

system("pause");

}

？？？？问题：const引用，

const Type& name = var；

const引用让变量拥有仅仅读属性

int main()

{

int a = 10;

const
int &b = a;

//int *p = (int *)&b;

b = 11; //err

//*p = 11; //仅仅能用指针来改变了

cout<<"b--->"<<a<<endl;

printf("a:%d\n", a);

printf("b:%d\n", b);

printf("&a:%d\n", &a);

printf("&b:%d\n", &b);

system("pause");

return 0;

}

void main41()

{

int a = 10;

const int &b = a; //const引用使用变量a初始化

a = 11;

//b = 12; //通过引用改动a,对不起改动不了

system("pause");

}

struct Teacher1

{

char name[64];

int age;

};

void printTe2(const Teacher1 *const pt)

{

}

//const引用让变量(所指内存空间)拥有仅仅读属性

void printTe(const Teacher1 &t)

{

//t.age  = 11;

}

void main42()

{

Teacher1 t1;

t1.age = 33;

printTe(t1);

system("pause");

}

1、用变量对const引用初始化。const引用分配内存空间了吗？

2、用常量对const引用初始化，const引用分配内存空间了吗？

{

const int b = 10;

printf("b:%d", &b);

//int &a1 = 19; 假设不加const编译失败

const int &a = 19;

printf("&a:%d \n", &a);

system("pause");

}

{

//普通引用

int a = 10;

int &b = a;

//常量引用：让变量引用仅仅读属性

const int &c = a;

//常量引用初始化分为两种

//1 用变量 初始化 常量引用

{

int x = 20;

const int& y = x;

printf("y:%d \n", y);

}

//2 用常量 初始化 常量引用

{

//int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用

const int &m = 10;

}

cout<<"hello..."<<endl;

system("pause");

return ;

}

{

static int a = 0;

return a;

}

int& g()

{

int a = 0;

return a;

}

int main()

{

int a = g();

int& b = g();

j() = 10;

printf("a = %d\n", a);

printf("b = %d\n", b);

printf("f() = %d\n", f());

system("pause");

return 0;

}

const int A = 3;  #define A 3

C++中是否有解决方式替代宏代码片段呢？（替代宏代码片段就能够避免宏的副作用！

）

C++中使用inlinekeyword声明内联函数

//宏替换和函数调用差别

using namespace std;

#define MYFUNC(a, b) ((a) < (b) ? (a) : (b))

inline int myfunc(int a, int b)

{

return a < b ? a : b;

}

int main()

{

int a = 1;

int b = 3;

//int c = myfunc(++a, b);  //头疼系统

int c = MYFUNC(++a, b);

printf("a = %d\n", a);

printf("b = %d\n", b);

printf("c = %d\n", c);

system("pause");

return 0;

}

必须inline int myfunc(int a, int b)和函数体的实现，写在一块

被C++编译器内联编译的函数叫做内联函数

内联函数在终于生成的代码中是未定义的

C++编译器直接将函数体插入在函数调用的地方

内联函数没有普通函数调用时的额外开销(压栈，跳转，返回)

说明4

内联函数是一种特殊的函数。具有普通函数的特征（參数检查，返回类型等）

内联函数是对编译器的一种请求。因此编译器可能拒绝这样的请求

内联函数由 编译器处理。直接将编译后的函数体插入调用的地方

宏代码片段 由预处理器处理。 进行简单的文本替换，没有不论什么编译过程

现代C++编译器可以进行编译优化，因此一些函数即使没有inline声明，也可能被编译器内联编译

另外，一些现代C++编译器提供了扩展语法，可以对函数进行强制内联

如：g++中的__attribute__((always_inline))属性

C++中内联编译的限制：

不能存在不论什么形式的循环语句

不能存在过多的条件推断语句

函数体不能过于庞大

不能对函数进行取址操作

函数内联声明必须在调用语句之前

因此。当函数体的运行开销远大于压栈，跳转和返回所用的开销时，那么内联将无意义。

1）内联函数在编译时直接将函数体插入函数调用的地方

2）inline仅仅是一种请求。编译器不一定同意这样的请求

3）内联函数省去了普通函数调用时压栈，跳转和返回的开销

C++中能够在函数声明时为參数提供一个默认值。

当函数调用时没有指定这个參数的值，编译器会自己主动用默认值取代

*/

{

printf("x:%d", x);

}

/*2

函数默认參数的规则

仅仅有參数列表后面部分的參数才干够提供默认參数值

一旦在一个函数调用中開始使用默认參数值。那么这个參数后的全部參数都必须使用默认參数值

*/

void printAB(int x = 3)

{

printf("x:%d\n", x);

}

//在默认參数规则 ，假设默认參数出现。那么右边的都必须有默认參数

void printABC(int a, int b, int x = 3, int y=4, int z = 5)

{

printf("x:%d\n", x);

}

int main62(int argc, char *argv[])

{

printAB(2);

printAB();

system("pause");

return 0;

}

函数占位參数

占位參数仅仅有參数类型声明。而没有參数名声明

普通情况下，在函数体内部无法使用占位參数

*/

{

return a + b;

}

int main01()

{

//func(1, 2); //能够吗？

printf("func(1, 2, 3) = %d\n", func(1, 2, 3));

getchar();

return 0;

}

能够将占位參数与默认參数结合起来使用

意义

为以后程序的扩展留下线索

兼容C语言程序中可能出现的不规范写法

*/

//C++能够声明占位符參数，占位符參数一般用于程序扩展和对C代码的兼容

{

return a + b;

}

void main()

{

//假设默认參数和占位參数在一起，都能调用起来

func2(1, 2);

func2(1, 2, 3);

system("pause");

}

函数重载(Function Overload)

用同一个函数名定义不同的函数

当函数名和不同的參数搭配时函数的含义不同

2 函数重载的推断标准

/*

函数重载至少满足以下的一个条件：

參数个数不同

參数类型不同

參数顺序不同

*/

3 函数返回值不是函数重载的推断标准

实验1：调用情况分析；实验2：推断标准

/*

int func(int x)

{

return x;

}

int func(int a, int b)

{

return a + b;

}

int func(const char* s)

{

return strlen(s);

}

int main()

{

int c = 0;

c = func(1);

printf("c = %d\n", c);

c = func(1, 2);

printf("c = %d\n", c);

c = func("12345");

printf("c = %d\n", c);

printf("Press enter to continue ...");

getchar();

return 0;

}

*/

编译器调用重载函数的准则

将全部同名函数作为候选者

尝试寻找可行的候选函数

精确匹配实參

通过默认參数可以匹配实參

通过默认类型转换匹配实參

匹配失败

终于寻找到的可行候选函数不唯一，则出现二义性。编译失败。

无法匹配全部候选者，函数没有定义，编译失败。

*/

/*

函数重载的注意事项

重载函数在本质上是相互独立的不同函数（静态链编）

重载函数的函数类型是不同的

函数返回值不能作为函数重载的根据

函数重载是由函数名和參数列表决定的。

*/

/*

int func(int a, int b, int c = 0)

{

return a * b * c;

}

int func(int a, int b)

{

return a + b;

}

//1个參数的同意吗

int func(int a)

{

         return a + b;

}

int main()

{

int c = 0;

c = func(1, 2); // 存在二义性。调用失败，编译不能通过

printf("c = %d\n", c);

printf("Press enter to continue ...");

getchar();

return 0;

}

*/

函数重载与函数指针

当使用重载函数名对函数指针进行赋值时

依据重载规则挑选与函数指针參数列表一致的候选者

严格匹配候选者的函数类型与函数指针的函数类型

*/

/*

int func(int x) // int(int a)

{

return x;

}

int func(int a, int b)

{

return a + b;

}

int func(const char* s)

{

return strlen(s);

}

typedef int(*PFUNC)(int a); // int(int a)

int main()

{

int c = 0;

PFUNC p = func;

c = p(1);

printf("c = %d\n", c);

printf("Press enter to continue ...");

getchar();

return 0;

}

*/

一、皇帝身边的小太监----寄存器

不知道什么是寄存器？那见过太监没有？没有？事实上我也没有。没见过不要紧，见过就麻烦大了。^_^，大家都看过古装戏，那些皇帝们要阅读奏章的时候，大臣总是先将奏章交给皇帝旁边的小太监，小太监呢再交给皇帝同志处理。这个小太监仅仅是个中转站。并无别的功能。

好，那我们再联想到我们的CPU。CPU 不就是我们的皇帝同志么？大臣就相当于我们的内存。数据从他这拿出来。

那小太监就是我们的寄存器了（这里先不考虑CPU 的快速缓存区）。

数据从内存里拿出来先放到寄存器，然后CPU 再从寄存器里读取数据来处理，处理完后相同把数据通过寄存器存放到内存里。CPU不直接和内存打交道。这里要说明的一点是:小太监是主动的从大臣手里接过奏章，然后主动的交给皇帝同志。但寄存器没这么自觉，它从不主动干什么事。一个皇帝可能有好些小太监，那么一个CPU
也能够有非常多寄存器，不同型号的CPU 拥有寄存器的数量不一样。

为啥要这么麻烦啊？速度。就是由于速度。

寄存器事实上就是一块一块小的存储空间，仅仅只是其存取速度要比内存快得多。进水楼台先得月嘛。它离CPU 非常近。CPU 一伸手就拿到数据了，比在那么大的一块内存里去寻找某个地址上的数据是不是快多了？那有人问既然它速度那么快，那我们的内存硬盘都改成寄存器得了呗。我要说的是：你真有钱！

register修饰符暗示编译程序对应的变量将被频繁地使用，假设可能的话，应将其保存在CPU的寄存器中。以加快其存储速度。比如以下的内存块拷贝代码。

　　#ifdef NOSTRUCTASSIGN

　　memcpy (d, s, l)

　　{

register char *d;

　　    register char *s;

　　    register int i;

　　    while (i--)

　　        *d++ = *s++;

　　}

　　#endif

三、使用register 修饰符的注意点

可是使用register修饰符有几点限制。

　　首先，register变量必须是能被CPU所接受的类型。这通常意味着register变量必须是一个单个的值。而且长度应该小于或者等于整型的长度。只是。有些机器的寄存器也能存放浮点数。

　　其次，由于register变量可能不存放在内存中，所以不能用“&”来获取register变量的地址。

　　因为寄存器的数量有限，并且某些寄存器仅仅能接受特定类型的数据（如指针和浮点数），因此真正起作用的register修饰符的数目和类型都依赖于执行程序的机器，而不论什么多余的register修饰符都将被编译程序所忽略。

　　在某些情况下，把变量保存在寄存器中反而会减少程序的执行速度。由于被占用的寄存器不能再用于其他目的；或者变量被使用的次数不够多，不足以装入和存储变量所带来的额外开销。

　　早期的C编译程序不会把变量保存在寄存器中。除非你命令它这样做。这时register修饰符是C语言的一种非常有价值的补充。然而，随着编译程序设计技术的进步，在决定那些变量应该被存到寄存器中时，如今的C编译环境能比程序猿做出更好的决定。实际上，很多编译程序都会忽略register修饰符。由于虽然它全然合法。但它只是暗示而不是命令。

//类的内部。类的外部

//我们抽象了一个类。用类去定义对象

//类是一个数据类型。类是抽象的

//对象是一个详细的变量。。

占用内存空间。

class Circle

{

public:

double r;

double s;

public:

double getR()

{

a++;

return r;

}

void setR(double val)

{

r = val;

}

public:

double getS() //添加功能时，是在改动类, 改动类中的属性或者是方法

{

s = 3.14f*r*r;

return s;

}

//private:

int a;

};

#include "iostream"

using namespace std;

/*

思考为什么须要初始化

面向对象思想来自生活，手机、车、电子产品，出厂时有初始化

怎么样进行初始化？

方案1：显示调用方法

缺点：易忘、麻烦。显示调用init，不能全然解决这个问题

*/

class Test21

{

public:

int m;

int getM() const { return m; }

void setM(int val) { m = val; }

int n;

int getN() const { return n; }

void setN(int val) { n = val; }

public:

int init(int m,int n)

{

this->m = m;

this->n = n;

return 0;

}

protected:

private:

};

int main()

{

int rv =0;

Test21 t1;  //无參构造函数的调用方法

Test21 t2;

//t1.init(100, 200);

//t2.init(300, 400);

cout<<t1.getM()<<" "<<t1.getN()<<endl;

cout<<t2.getM()<<" "<<t2.getN()<<endl;

//定义对象数组时，没有机会进行显示初始化

Test21 arr[3];

//Test arr_2[3] = {Test(1,3), Test(), Test()};

system("pause");

return rv;

}

class Test

{

private:

int a;

int b;

public:

//无參数构造函数

Test()

{

;

}

//带參数的构造函数

Test(int a, int b)

{

;

}

//赋值构造函数

Test(const Test &obj)

{

;

}

public:

void init(int _a, int _b)

{

a = _a;

b = _b;

}

};

class Test5

{

private:

int a;

public:

//带參数的构造函数

Test5(int a)

{

printf("\na:%d", a);

}

Test5(int a, int b)

{

printf("\na:%d b:%d", a, b);

}

public:

};

int main55()

{

Test5 t1(10);  //c++编译器默认调用有參构造函数 括号法

Test5 t2 = (20, 10); //c++编译器默认调用有參构造函数 等号法

Test5 t3 = Test5(30); //程序猿手工调用构造函数 产生了一个对象 直接调用构造构造函数法

system("pause");

return 0;

}

using namespace std;

class AA

{

public:

AA() //无參构造函数 默认构造函数

{

cout<<"我是构造函数。自己主动被调用了"<<endl;

}

AA(int _a) //无參构造函数 默认构造函数

{

a = _a;

}

AA(const AA &obj2)

{

cout<<"我也是构造函数，我是通过另外一个对象obj2，来初始化我自己"<<endl;

a = obj2.a + 10;

}

~AA()

{

cout<<"我是析构函数，自己主动被调用了"<<endl;

}

void getA()

{

printf("a:%d \n", a);

}

protected:

private:

int a;

};

//单独搭建一个舞台

void ObjPlay01()

{

AA a1; //变量定义

//赋值构造函数的第一个应用场景

//用对象1 初始化 对象2

AA a2 = a1; //定义变量并初始化 //初始化法

a2 = a1; //用a1来=号给a2 编译器给我们提供的浅copy

}

//单独搭建一个舞台

void ObjPlay02()

{

AA a1(10); //变量定义

//赋值构造函数的第一个应用场景

//用对象1 初始化 对象2

AA a2(a1); //定义变量并初始化 //括号法

//a2 = a1; //用a1来=号给a2 编译器给我们提供的浅copy

a2.getA();

}

//注意：初始化操作 和 等号操作 是两个不同的概念

using namespace std;

class Location

{

public:

Location( int xx = 0 , int yy = 0 )

{

X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ;

}

Location( const Location & p )            //拷贝构造函数

{

X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;

}

~Location()

{

cout << X << "," << Y << " Object destroyed." << endl ;

}

int  GetX () { return X ; }          int GetY () { return Y ; }

private :   int  X , Y ;

} ;

//alt + f8 排版

void f ( Location  p )

{

cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ;

}

void mainobjplay()

{

Location A ( 1, 2 ) ;  //形參是一个元素，函数调用，会运行实參变量初始化形參变量

f ( A ) ;

}

void main()

{

mainobjplay();

system("pause");

}

#include "iostream"

using namespace std;

class Location

{

public:

Location( int xx = 0 , int yy = 0 )

{

X = xx ;  Y = yy ;  cout << "Constructor Object.\n" ;

}

Location( const Location & p )            //复制构造函数

{

X = p.X ;  Y = p.Y ;   cout << "Copy_constructor called." << endl ;

}

~Location()

{

cout << X << "," << Y << " Object destroyed." << endl ;

}

int  GetX () { return X ; }          int GetY () { return Y ; }

private :   int  X , Y ;

} ;

//alt + f8 排版

void f ( Location  p )

{

cout << "Funtion:" << p.GetX() << "," << p.GetY() << endl ;

}

Location g()

{

Location A(1, 2);

return A;

}

//对象初始化操作 和 =等号操作 是两个不同的概念

//匿名对象的去和留。关键看。返回时怎样接

void mainobjplay()

{

//若返回的匿名对象。赋值给另外一个同类型的对象。那么匿名对象会被析构

//Location B;

//B = g();  //用匿名对象赋值给B对象，然后匿名对象析构

//若返回的匿名对象，来初始化另外一个同类型的对象，那么匿名对象会直接转成新的对象

Location B = g();

cout<<"传智扫地僧測试"<<endl;

}

void main()

{

mainobjplay();

system("pause");

}

{

public:

Name(const char *pname)

{

size = strlen(pname);

pName = (char *)malloc(size + 1);

strcpy(pName, pname);

}

Name(Name &obj)

{

//用obj来初始化自己

pName = (char *)malloc(obj.size + 1);

strcpy(pName, obj.pName);

size = obj.size;

}

~Name()

{

cout<<"開始析构"<<endl;

if (pName!=NULL)

{

free(pName);

pName = NULL;

size = 0;

}

}

void operator=(Name &obj3)

{

if (pName != NULL)

{

free(pName);

pName = NULL;

size = 0;

}

cout<<"測试有没有调用我。

。。。"<<endl;

//用obj3来=自己

pName = (char *)malloc(obj3.size + 1);

strcpy(pName, obj3.pName);

size = obj3.size;

}

protected:

private:

char *pName;

int size;

};

//对象的初始化 和 对象之间=号操作是两个不同的概念

void playObj()

{

Name obj1("obj1.....");

Name obj2 = obj1; //obj2创建并初始化

Name obj3("obj3...");

//重载=号操作符

obj2 = obj3; //=号操作

cout<<"业务操作。。。5000"<<endl;

}

void main61()

{

playObj();

system("pause");

}

1 C++中提供了初始化列表对成员变量进行初始化

2 使用初始化列表出现原因：

1.必须这样做：

假设我们有一个类成员。它本身是一个类或者是一个结构，并且这个成员它仅仅有一个带參数的构造函数，

而没有默认构造函数，这时要对这个类成员进行初始化，就必须调用这个类成员的带參数的构造函数，

假设没有初始化列表，那么他将无法完毕第一步，就会报错。

2、类成员中若有const修饰，必须在对象初始化的时候，给const int m 赋值

当类成员中含有一个const对象时，或者是一个引用时，他们也必需要通过成员初始化列表进行初始化，

由于这两种对象要在声明后立即初始化。而在构造函数中，做的是对他们的赋值，这样是不被同意的。

*/

//总结 构造和析构的调用顺序

#include "iostream"

using namespace std;

class ABC

{

public:

ABC(int a, int b, int c)

{

this->a = a;

this->b = b;

this->c = c;

printf("a:%d,b:%d,c:%d \n", a, b, c);

printf("ABC construct ..\n");

}

~ABC()

{

printf("a:%d,b:%d,c:%d \n", a, b, c);

printf("~ABC() ..\n");

}

protected:

private:

int a;

int b;

int c;

};

class MyD

{

public:

MyD():abc1(1,2,3),abc2(4,5,6),m(100)

//MyD()

{

cout<<"MyD()"<<endl;

}

~MyD()

{

cout<<"~MyD()"<<endl;

}

protected:

private:

ABC abc1; //c++编译器不知道怎样构造abc1

ABC abc2;

const int m;

};

int run()

{

MyD myD;

return 0;

}

int main_dem03()

{

run();

system("pause");

return 0;

}

C++编译器怎样完毕面向对象理论到计算机程序的转化？

换句话：C++编译器是怎样管理类、对象、类和对象之间的关系

详细的说：详细对象调用类中的方法，那，c++编译器是怎样区分，是那个详细的类，调用这种方法那?

using namespace std;

class C1

{

public:

int i;  //4

int j; //4

int k;  //4

protected:

private:

}; //12

class C2

{

public:

int i; //4

int j; //4

int k; //4

static int m; //4

public:

int getK() const { return k; } //4

void setK(int val) { k = val; }  //4

protected:

private:

}; //12 16 24

struct S1

{

int i;

int j;

int k;

}; //

struct S2

{

int i;

int j;

int k;

static int m;

}; //

int main()

{

printf("c1:%d \n", sizeof(C1));

printf("c2:%d \n", sizeof(C2));

printf("s1:%d \n", sizeof(S1));

printf("s2:%d \n", sizeof(S2));

system("pause");

}

1）C++类对象中的成员变量和成员函数是分开存储的

成员变量：

普通成员变量：存储于对象中。与struct变量有同样的内存布局和字节对齐方式

静态成员变量：存储于全局数据区中

成员函数：存储于代码段中。

问题出来了：非常多对象共用一块代码？代码是怎样区分详细对象的那？

换句话说：int getK() const { return k; }，代码是怎样区分。详细obj1、obj2、obj3对象的k值？

2、C++中类的普通成员函数都隐式包括一个指向当前对象的this指针。

3、静态成员函数、成员变量属于类

静态成员函数与普通成员函数的差别

静态成员函数不包括指向详细对象的指针

普通成员函数包括一个指向详细对象的指针

{

public:

A1()

{

a1 = 100;

a2 = 200;

}

int getA1()

{

return this->a1;

}

//声明一个友元函数

friend void setA1(A1 *p, int a1); //这个函数是这个类的好朋友

protected:

private:

int a1;

int a2;

};

void setA1(A1 *p, int a1)

{

p->a1 = a1;

}

void main()

{

A1 mya1;

cout<<mya1.getA1()<<endl;

setA1(&mya1, 300); //通过友元函数 改动A类的私有属性

cout<<mya1.getA1()<<endl;

system("pause");

}

using namespace std;

class Goods

{

public :

Goods ( int  w) { weight = w ;  total_weight += w ; }

~ Goods() { total_weight -= weight ; }

int  Weight() { return  weight ; } ;

static  int  TotalWeight() { return  total_weight ; }

Goods *next ;

private :

int  weight ;

static  int  total_weight ;

} ;

int  Goods::total_weight = 0 ;

//r尾部指针

void purchase( Goods * &f, Goods *& r, int w )

{

Goods *p = new Goods(w) ;

p -> next = NULL ;

if ( f == NULL )  f = r = p ;

else { r -> next = p ;    r = r -> next ; } //尾部指针下移或新结点变成尾部结点

}

void sale( Goods * & f , Goods * & r )

{

if ( f == NULL ) { cout << "No any goods!\n" ;  return ; }

Goods *q = f ;  f = f -> next ;  delete q ;

cout << "saled.\n" ;

}

void main()

{

Goods * front = NULL , * rear = NULL ;

int  w ;  int  choice ;

do

{

cout << "Please choice:\n" ;

cout << "Key in 1 is purchase,\nKey in 2 is sale,\nKey in 0 is over.\n" ;

cin >> choice ;

switch ( choice )                 // 操作选择

{

case 1 :                           // 键入1，购进1箱货物

{  cout << "Input weight: " ;

cin >> w ;

purchase( front, rear, w ) ;         // 从表尾插入1个结点

break ;

}

case 2 :                        // 键入2，售出1箱货物

{ sale( front, rear ) ;    break ; }       // 从表头删除1个结点

case 0 :  break ;                         // 键入0，结束

}

cout << "Now total weight is:" << Goods::TotalWeight() << endl ;

} while ( choice ) ;

}

#include "Array.h"

using namespace std;

int main()

{

Array a1(10);

for(int i=0; i<a1.length(); i++)

{

a1.setData(i, i);

}

for(int i=0; i<a1.length(); i++)

{

printf("array %d: %d\n", i, a1.getData(i));

}

Array a2 = a1;

for(int i=0; i<a2.length(); i++)

{

printf("array %d: %d\n", i, a2.getData(i));

}

system("pause");

return 0;

}

#define _MYARRAY_H_

class Array

{

private:

int mLength;

int* mSpace;

public:

Array(int length);

Array(const Array& obj);

int length();

void setData(int index, int value);

int getData(int index);

~Array();

};

#endif

{

public:

int a;

int b;

friend Complex operator+(Complex &c1, Complex &c2);

public:

Complex(int a=0, int b=0)

{

this->a = a;

this->b = b;

}

public:

void printCom()

{

cout<<a<<" + "<<b<<"i "<<endl;

}

private:

};

/*

Complex myAdd(Complex &c1, Complex &c2)

{

Complex tmp(c1.a+ c2.a, c1.b + c2.b);

return tmp;

}

*/

Complex operator+(Complex &c1, Complex &c2)

{

Complex tmp(c1.a+ c2.a, c1.b + c2.b);

return tmp;

}

void main()

{

Complex c1(1, 2), c2(3, 4);

//Complex c3 = c1 + c2;  //用户自己定义类型 编译器无法让变量相加

//Complex myAdd(Complex &c1, Complex &c2);

//1 普通函数

//Complex c3 = myAdd(c1, c2);

//c3.printCom();

//2 operator+ 函数名称

//Complex c3 = operator+(c1, c2);

//c3.printCom();

//3 +替换 函数名

Complex c3 = c1 + c2; //思考C++编译器怎样支持操作符重载机制的 (依据类型)

c3.printCom();

{

int a =0, b = 0, c; //基础类型C++编译器知道怎样加减

c = a +b;

}

//4 把Complex类变成私有属性

//友元函数的应用场景

//friend Complex operator+(Complex &c1, Complex &c2);

cout<<"hello..."<<endl;

system("pause");

return ;

}

using namespace std;

//为vector类重载流插入运算符和提取运算符

class vector

{

public :

vector( int size =1 ) ;

~vector() ;

int & operator[]( int i ) ;

friend ostream & operator << ( ostream & output , vector & ) ;

friend istream & operator >> ( istream & input, vector & ) ;

private :

int * v ;

int len ;

};

vector::vector( int size )

{

if (size <= 0 || size > 100 )

{

cout << "The size of " << size << " is null !\n" ; abort() ;

}

v = new int[ size ] ;  len = size ;

}

vector :: ~vector()

{

delete[] v ;

len = 0 ;

}

int &vector::operator[]( int i )

{

if( i >=0 && i < len )  return v[ i ] ;

cout << "The subscript " << i << " is outside !\n" ;  abort() ;

}

ostream & operator << ( ostream & output, vector & ary )

{

for(int i = 0 ; i < ary.len ; i ++ )

output << ary[ i ] << "  " ;

output << endl ;

return output ;

}

istream & operator >> ( istream & input, vector & ary )

{

for( int i = 0 ; i < ary.len ; i ++ )

input >> ary[ i ] ;

return  input ;

}

void main()

{

int k ;

cout << "Input the length of vector A :\n" ;

cin >> k ;

vector A( k ) ;

cout << "Input the elements of vector A :\n" ;

cin >> A ;

cout << "Output the elements of vector A :\n" ;

cout << A ;

system("pause");

}

// obj4 = obj3 = obj1

//obj3.operator=(obj1)

Name& operator=(Name &obj1)

{

//1 先释放obj3旧的内存

if (this->m_p != NULL)

{

delete[] m_p;

m_len = 0;

}

//2 依据obj1分配内存大小

this->m_len = obj1.m_len;

this->m_p = new char [m_len+1];

//3把obj1赋值给obj3

strcpy(m_p, obj1.m_p);

return *this;

}

#include <iostream>

using namespace std;

class Test

{

int i;

public:

Test(int i)

{

this->i = i;

}

Test operator+ (const Test& obj)

{

Test ret(0);

cout<<"运行+号重载函数"<<endl;

ret.i = i + obj.i;

return ret;

}

bool operator&& (const Test& obj)

{

cout<<"运行&&重载函数"<<endl;

return i && obj.i;

}

};

// && 从左向右

void main()

{

int a1 = 0;

int a2 = 1;

cout<<"注意：&&操作符的结合顺序是从左向右"<<endl;

if( a1 && (a1 + a2) )

{

cout<<"有一个是假，则不在运行下一个表达式的计算"<<endl;

}

Test t1 = 0;

Test t2 = 1;

If ( t1 && (t1 + t2) )

{

=è

T1.operator&&(   t1 + t2)  )

T1.operator&&(   t1.operator+(t2) )

//t1  && t1.operator+(t2)

// t1.operator(  t1.operator(t2)  )

cout<<"两个函数都被运行了，并且是先运行了+"<<endl;

}

system("pause");

return ;

}

//C++中 我们来设计一个字符串 以零结尾的字符串

class MyString

{

friend ostream& operator<<(ostream &out, const MyString &s);

public: //构造和析构

MyString(int len = 0);

MyString(const char *p);

MyString(const MyString& obj);

~MyString();

public: //操作符重载

MyString& operator=(const char *p);

MyString& operator=(const MyString& obj);

char& operator[](int index) const;

public:

bool operator==(const char* p) const;

bool operator!=(const char* p) const;

bool operator==(const MyString& s) const;

bool operator!=(const MyString& s) const;

public: //string to c

char *c_str();

const char* c_str() const;

int length()

{

return m_len;

}

public:

int operator<(const char *p);

int operator>(const char *p);

int operator<(const MyString &s);

int operator>(const MyString &s);

private:

int              m_len;

char *m_p;

};

{

public:

Test()

{

this->a = 10;

}

void printT()

{

cout<<a<<endl;

}

private:

int a;

};

class MyTestPointer

{

public:

public:

MyTestPointer()

{

p = NULL;

}

MyTestPointer(Test* p)

{

this->p = p;

}

~MyTestPointer()

{

delete p;

}

Test* operator->()

{

return p;

}

Test& operator*()

{

return *p;

}

protected:

Test *p;

};

void main01_classp()

{

Test *p = new Test;

p->printT();

delete p;

MyTestPointer myp = new Test; //构造函数

myp->printT(); //重载操作符 ->

};

{

public:

public:

MyIntPointer()

{

p = NULL;

}

MyIntPointer(int* p)

{

this->p = p;

}

~MyIntPointer()

{

delete p;

}

int* operator->()

{

return p;

}

int& operator*()

{

return *p;

}

protected:

int *p;

};

void main02_intp()

{

int *p = new int(100);

cout<<*p<<endl;

delete p;

MyIntPointer myp = new int(200);

cout<<*myp<<endl; //重载*操作符

};

承

方

式

#include <cstdlib>

#include <iostream>

using namespace std;

class A

{

private:

int a;

protected:

int b;

public:

int c;

A()

{

a = 0;

b = 0;

c = 0;

}

void set(int a, int b, int c)

{

this->a = a;

this->b = b;

this->c = c;

}

};

class B : public A

{

public:

void print()

{

//cout<<"a = "<<a; //err

cout<<"b = "<<b;

cout<<"c = "<<endl;

}

};

class C : protected A

{

public:

void print()

{

//cout<<"a = "<<a; //err

cout<<"b = "<<b;

cout<<"c = "<<endl;

}

};

class D : private A

{

public:

void print()

{

//cout<<"a = "<<a; //err

cout<<"b = "<<b<<endl;

cout<<"c = "<<c<<endl;

}

};

int main_01(int argc, char *argv[])

{

A aa;

B bb;

C cc;

D dd;

aa.c = 100; //ok

bb.c = 100; //ok

//cc.c = 100; //err 类的外部是什么含义

//dd.c = 100; //err

aa.set(1, 2, 3);

bb.set(10, 20, 30);

//cc.set(40, 50, 60); //ee

//dd.set(70, 80, 90); //ee

bb.print();

cc.print();

dd.print();

system("pause");

return 0;

}

#include <iostream>

using namespace std;

/*

子类对象能够当作父类对象使用

子类对象能够直接赋值给父类对象

子类对象能够直接初始化父类对象

父类指针能够直接指向子类对象

父类引用能够直接引用子类对象

*/

//子类就是特殊的父类

class Parent03

{

protected:

const char* name;

public:

Parent03()

{

name = "Parent03";

}

void print()

{

cout<<"Name: "<<name<<endl;

}

};

class Child03 : public Parent03

{

protected:

int i;

public:

Child03(int i)

{

this->name = "Child2";

this->i = i;

}

};

int main()

{

Child03 child03(1000);

//分别定义父类对象 父类指针 父类引用 child

Parent03 parent = child03;

Parent03* pp = &child03;

Parent03& rp = child03;

parent.print();

pp->print();

rp.print();

system("pause");

return 0;

}

#include <iostream>

using namespace std;

class Parent04

{

public:

Parent04(const char* s)

{

cout<<"Parent04()"<<" "<<s<<endl;

}

~Parent04()

{

cout<<"~Parent04()"<<endl;

}

};

class Child04 : public Parent04

{

public:

Child04() : Parent04("Parameter from Child!")

{

cout<<"Child04()"<<endl;

}

~Child04()

{

cout<<"~Child04()"<<endl;

}

};

void run04()

{

Child04 child;

}

int main_04(int argc, char *argv[])

{

run04();

system("pause");

return 0;

}

//继承中的构造和析构

//继承和组合混搭情况下，构造函数、析构函数调用顺序研究

#include <iostream>

using namespace std;

class Object

{

public:

Object(const char* s)

{

cout<<"Object()"<<" "<<s<<endl;

}

~Object()

{

cout<<"~Object()"<<endl;

}

};

class Parent : public Object

{

public:

Parent(const char* s) : Object(s)

{

cout<<"Parent()"<<" "<<s<<endl;

}

~Parent()

{

cout<<"~Parent()"<<endl;

}

};

class Child : public Parent

{

protected:

Object o1;

Object o2;

public:

Child() : o2("o2"), o1("o1"), Parent("Parameter from Child!")

{

cout<<"Child()"<<endl;

}

~Child()

{

cout<<"~Child()"<<endl;

}

};

void run05()

{

Child child;

}

int main05(int argc, char *argv[])

{

cout<<"demo05_extend_construct_destory.cpp"<<endl;

run05();

system("pause");

return 0;

}

在子类中定义与父类中原型同样的函数

函数重写仅仅发生在父类与子类之间

{

public:

void print()

{

cout<<"Parent:print() do..."<<endl;

}

};

class Child : public Parent

{

public:

void print()

{

cout<<"Child:print() do..."<<endl;

}

};

int main01()

{

run00();

/*

Child child;

Parent *p = NULL;

p = &child;

child.print();

child.Parent::print();

*/

system("pause");

return 0;

}

默认情况下子类中重写的函数将隐藏父类中的函数

通过作用域分辨符::能够訪问到父类中被隐藏的函数

C/C++是静态编译型语言

在编译时，编译器自己主动依据指针的类型推断指向的是一个什么样的对象

*/

/*

1、在编译此函数的时。编译器不可能知道指针 p 到底指向了什么。

2、编译器没有理由报错。

3、于是，编译器觉得最安全的做法是编译到父类的print函数，由于父类和子类肯定都有同样的print函数。

*/

//面向对象新需求

//假设我传一个父类对象。运行父类的print函数

//假设我传一个子类对象，运行子类的printf函数

//现象产生的原因

//赋值兼容性原则遇上函数重写 出现的一个现象

//1 没有理由报错

//2 对被调用函数来讲。在编译器编译期间，我就确定了，这个函数的參数是p，是Parent类型的。。

。

//3静态链编

//project开发中怎样推断是不是多态存在？

/*

在同一个类里面能实现函数重载

继承的情况下。发生重写

重载不一定;

重写的定义

静态联编 重载是

动态联编

*/

#include <iostream>

using namespace std;

class Parent

{

public:

void print()

{

cout<<"Parent:print() do..."<<endl;

}

};

class Child : public Parent

{

public:

void print()

{

cout<<"Child:print() do..."<<endl;

}

};

/*

1、在编译此函数的时，编译器不可能知道指针 p 到底指向了什么。

2、编译器没有理由报错。

3、于是，编译器觉得最安全的做法是编译到父类的print函数，由于父类和子类肯定都有同样的print函数。

*/

void howToPrint(Parent* p)

{

p->print();

}

void run00()

{

Child child;

Parent* pp = &child;

Parent& rp = child;

//child.print();

//通过指针

//pp->print();

//通过引用

//rp.print();

howToPrint(&child);

}

int main01()

{

run00();

/*

Child child;

Parent *p = NULL;

p = &child;

child.print();

child.Parent::print();

*/

system("pause");

return 0;

}

using namespace std;

class HeroFighter

{

public:

public:

virtual int ackPower()

{

return 10;

}

};

class AdvHeroFighter : public HeroFighter

{

public:

virtual int ackPower()

{

return HeroFighter::ackPower()*2;

}

};

class enemyFighter

{

public:

int destoryPower()

{

return 15;

}

};

//假设把这个结构放在动态库里面

//写了一个框架，能够调用

//我的第3代战机代码出现的时间晚于框架出现的时间。。。

。

//框架 有使用后来人 写的代码的能力。。。

//面向对象3大概念

/*

封装

突破了C语言函数的概念。

。

继承

代码复用 。。

。。

我复用原来写好的代码。。。

多态

多态能够使用未来。。。。

。

80年代写了一个框架。。

。

。。。

90人写的代码

多态是我们软件行业追寻的一个目标。

。。

////

*/

//

void objPK(HeroFighter *hf, enemyFighter *enemyF)

{

if (hf->ackPower() >enemyF->destoryPower())

{

printf("英雄打败敌人。

。

。胜利\n");

}

else

{

printf("英雄。。。

牺牲\n");

}

}

void main()

{

HeroFighter hf;

enemyFighter ef;

objPK(&hf, &ef);

AdvHeroFighter advhf;

objPK(&advhf, &ef);

system("pause");

}

2、在编译时，编译器自己主动依据指针的类型推断指向的是一个什么样的对象；所以编译器觉得父类指针指向的是父类对象。

3、因为程序没有执行。所以不可能知道父类指针指向的详细是父类对象还是子类对象

从程序安全的角度，编译器如果父类指针仅仅指向父类对象。因此编译的结果为调用父类的成员函数。这样的特性就是静态联编。

多态：相同的调用语句有多种不同的表现形态；

多态实现的三个条件

有继承、有virtual重写、有父类指针（引用）指向子类对象。

多态的C++实现

virtualkeyword，告诉编译器这个函数要支持多态。不是依据指针类型推断怎样调用；而是要依据指针所指向的实际对象类型来推断怎样调用

多态的理论基础

动态联编PK静态联编。依据实际的对象类型来推断重写函数的调用。

多态的重要意义

设计模式的基础 是框架的基石。

实现多态的理论基础

函数指针做函数參数

C函数指针是C++至高无上的荣耀。C函数指针一般有两种使用方法（正、反）。

多态原理探究

与面试官展开讨论

#include <iostream>

using namespace std;

class Parent01

{

public:

Parent01()

{

cout<<"Parent01:printf()..do"<<endl;

}

public:

virtual void func()

{

cout<<"Parent01:void func()"<<endl;

}

virtual void func(int i)

{

cout<<"Parent:void func(int i)"<<endl;

}

virtual void func(int i, int j)

{

cout<<"Parent:void func(int i, int j)"<<endl;

}

};

class Child01 : public Parent01

{

public:

//此处2个參数。和子类func函数是什么关系

void func(int i, int j)

{

cout<<"Child:void func(int i, int j)"<<" "<<i + j<<endl;

}

//此处3个參数的。和子类func函数是什么关系

void func(int i, int j, int k)

{

cout<<"Child:void func(int i, int j, int k)"<<" "<<i + j + k<<endl;

}

};

void run01(Parent01* p)

{

p->func(1, 2);

}

int main()

{

Parent01 p;

p.func();

p.func(1);

p.func(1, 2);

Child01 c;

//c.func(); //问题1

c.Parent01::func();

c.func(1, 2);

run01(&p);

run01(&c);

system("pause");

return 0;

}

//问题1：child对象继承父类对象的func，请问这句话能执行吗？why

//c.func(); //由于名称覆盖。C++编译器不会去父类中寻找0个參数的func函数，仅仅会在子类中找func函数。

//1子类里面的func无法重载父类里面的func

//2当父类和子类有同样的函数名、变量名出现，发生名称覆盖（子类的函数名，覆盖了父类的函数名。

）

//3//c.Parent::func();

//问题2 子类的两个func和父类里的三个func函数是什么关系？

当类中声明虚函数时，编译器会在类中生成一个虚函数表

虚函数表是一个存储类成员函数指针的数据结构

虚函数表是由编译器自己主动生成与维护的

virtual成员函数会被编译器放入虚函数表中

存在虚函数时，每一个对象中都有一个指向虚函数表的指针(vptr指针)

通过虚函数表指针VPTR调用重写函数是在程序执行时进行的，因此须要通过寻址操作才干确定真正应该调用的函数。而普通成员函数是在编译时就确定了调用的函数。在效率上。虚函数的效率要低非常多。

说明2：

出于效率考虑，没有必要将全部成员函数都声明为虚函数

using namespace std;

class A

{

public:

void printf()

{

cout<<"aaa"<<endl;

}

protected:

private:

int a;

};

class B

{

public:

virtual void printf()

{

cout<<"aaa"<<endl;

}

protected:

private:

int a;

};

void main()

{

//加上virtualkeyword c++编译器会添加一个指向虚函数表的指针 。。。

printf("sizeof(a):%d, sizeof(b):%d \n", sizeof(A), sizeof(B));

cout<<"hello..."<<endl;

system("pause");

return ;

}

对象在创建的时,由编译器对VPTR指针进行初始化

仅仅有当对象的构造全然结束后VPTR的指向才终于确定

父类对象的VPTR指向父类虚函数表

子类对象的VPTR指向子类虚函数表

绘图分析

绝大多数面向对象语言都支持接口的概念

C++中没有接口的概念

C++中能够使用纯虚函数实现接口

接口类中仅仅有函数原型定义，没有不论什么数据的定义。

class Interface

{

public:

virtual void func1() = 0;

virtual void func2(int i) = 0;

virtual void func3(int i) = 0;

};

多重继承接口不会带来二义性和复杂性等问题

多重继承能够通过精心设计用单继承和接口来取代

接口类仅仅是一个功能说明。而不是功能实现。

子类须要依据功能说明定义功能实现。

using namespace std;

/*

C++中没有接口的概念

C++中能够使用纯虚函数实现接口

接口类中仅仅有函数原型定义，没有不论什么数据的定义。

*/

class Interface1

{

public:

virtual void print() = 0;

virtual int add(int a, int b) = 0;

};

class Interface2

{

public:

virtual void print() = 0;

virtual int add(int a, int b) = 0;

virtual int minus(int a, int b) = 0;

};

class parent

{

public:

int a;

};

class Child : public parent, public Interface1, public Interface2

{

public:

void print()

{

cout<<"Child::print"<<endl;

}

int add(int a, int b)

{

return a + b;

}

int minus(int a, int b)

{

return a - b;

}

};

int main()

{

Child c;

c.print();

cout<<c.add(3, 5)<<endl;

cout<<c.minus(4, 6)<<endl;

Interface1* i1 = &c;

Interface2* i2 = &c;

cout<<i1->add(7, 8)<<endl;

cout<<i2->add(7, 8)<<endl;

system("pause");

}

C语言中的函数有自己特定的类型

typedef type name(parameter list)

typedef int f(int, int);

typedef void p(int);

函数名是函数体的入口地址

1)可通过函数类型定义函数指针: FuncType* pointer;

2)也能够直接定义：type (*pointer)(parameter list);

pointer为函数指针变量名

type为指向函数的返回值类型

parameter list为指向函数的參数类型列表

//函数类型

//函数指针类型

//函数指针变量

数组指针语法梳理

//数组类型语法

//数组指针类型

//数组指针变量

int test(int i)

{

return i * i;

}

void f()

{

printf("Call f()...\n");

}

int main()

{

FUNC* pt = test;

void(*pf)() = &f;

pf();

(*pf)();

printf("Function pointer call: %d\n", pt(3));

}

回顾指针做函数參数

一级指针做函数參数、二级。

。

。。、三级

当函数指针 做为函数的參数，传递给一个被调用函数。

被调用函数就能够通过这个指针调用外部的函数，这就形成了回调

int add(int a, int b)

int libfun(  int (*pDis)(int a, int b)  );

int main(void)

{

int (*pfun)(int a, int b);

pfun = add;

libfun(pfun);

}

int add(int a, int b)

{

return a + b;

}

int libfun(  int (*pDis)(int a, int b)  )

{

int a, b;

a = 1;

b = 2;

add(1,3)  //直接调用add函数

printf("%d", pDis(a, b)); //通过函数指针做函数參数,间接调用add函数

//思考 这样写 pDis(a, b)有什么优点?

}

//剖析思路

//1函数的调用 和 函数的实现  有效的分离

//2 C++的多态,可扩展

如今这几个函数是在同一个文件其中

假如

int libfun(int (*pDis)(int a, int b))

是一个库中的函数，就仅仅有使用回调了。通过函数指针參数将外部函数地址传入

来实现调用

函数 add 的代码作了修改，也不必修改库的代码，就能够正常实现调用

便于程序的维护和升级

被调用函数和主调函数在同一文件里（用来教学，没有不论什么意义）

被调用函数和主调函数不在同一个文件里、模块中。

难点：理解被调用函数是什么机制被调用起来的。

框架

框架提前设置了被调用函数的入口（框架提供了第三方模块入口地址的集成功能）

框架具备调用第三方模块入口函数

typedef int (*EncDataFunc)(unsigned char *inData,int inDataLen,unsigned char *outData,int *outDataLen,void *Ref, int RefLen);

int MyEncDataFunc(unsigned char *inData,int inDataLen,unsigned char *outData,int *outDataLen,void *Ref, int RefLen)

{

int rv = 0;

char *p = "222222222222";

strcpy(outData, p);

*outDataLen = strlen(p);

return rv;

}

int Send_Data(EncDataFunc encDataFunc, unsigned char *inData, int inDataLen, unsigned char *outData, int *outDatalen)

{

int rv = 0;

if (encDataFunc != NULL)

{

rv = encDataFunc(inData, inDataLen, outData, outDatalen,  NULL, 0);

if (rv != 0)

{

printf("func encDataFunc() err.\n");

return rv;

}

}

return rv;

}

int main()

{

int rv = 0;

EncDataFunc encDataFunc = NULL;

encDataFunc = MyEncDataFunc;

// 第一个调用

{

unsigned char inData[2048];

int inDataLen;

unsigned char outData[2048];

int outDatalen;

strcpy(inData, "1111");

inDataLen = strlen(inData);

rv = encDataFunc(inData,inDataLen, outData, &outDatalen, NULL, 0);

if (rv != 0)

{

printf("edf err .....\n");

}

else

{

printf("edf ok \n");

printf("%s \n", outData);

}

}

{

unsigned char inData[2048];

int inDataLen;

unsigned char outData[2048];

int outDatalen;

strcpy(inData, "3333");

inDataLen = strlen(inData);

rv =  Send_Data(MyEncDataFunc, inData, inDataLen, outData, &outDatalen);

if (rv != 0)

{

printf("func Send_Data err:%d", rv);

return rv;

}

printf("%s \n", outData);

}

getchar();

}