// count the girth and area of circle

#include<iostream.h>

using name std;

void main ()

{ double r, girth, area ;

   const double PI = 3.1415 ;

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

   cin >> r ;  //输入

   girth = 2 * PI * r ;

   area = PI * r * r ;

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

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

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

}

#include<iostream.h> 

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 ;

}

// demo02_circle_err.cpp

#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语言是在实践的过程中逐步完善起来的

没有深思熟虑的设计过程

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

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

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

C语言的目标是高效

最终程序执行效率的高效

当面向过程方法论暴露越来越多的缺陷的时候，业界开始考虑在工程项目中引入面向对象的设计方法，而第一个需要解决的问题就是：高效的面向对象语言，并且能够兼容已经存在的代码。

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

C语言和C++并不是对立的竞争关系

C++是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++引入了关键字namespace（命名空间/名字空间/名称空间/名域），可以更好地控制标识符的作用域。

*/

/*

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

默认情况下可以直接使用默 认命名空间中的所有标识符

*/

namespace NameSpaceA

{

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 ", a);

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

NameSpaceB::NameSpaceC::Teacher t2

Teacher t1 = {"aaa", 3};

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

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

system("pause");

return 0;

}

#include "iostream"

using namespace std;

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

//C++中更强调语言的“实用性”，所有的变量都可以在需要使用时再定义。

int main11()

{

int i = 0;

printf("ddd");

int k;

system("pause");

return 0;

}

//register关键字 请求编译器让变量a直接放在寄存器里面，速度快

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

/*

//1

register关键字的变化

register关键字请求“编译器”将局部变量存储于寄存器中

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

在C++中依然支持register关键字

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

C++中可以取得register变量的地址

//2

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

//3

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

*/

int main22()

{

register int a = 0; 

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

system("pause");

return 0;

}

/*

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

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

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

int g_var;

int g_var = 1;

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

*/

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

{

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

return 0;

}

struct类型的加强：

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

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

struct Student

{

    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 ", i);

}

g()

{

return 5;

}

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

{

f(10);

printf("g() = %d ", 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 main(int argc, char *argv[])

{

int a;

bool b = true;

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

b = 4;

a = b;

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

b = -4;

a = b;

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

a = 10;

b = a;

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

b = 0;

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

system("pause");

return 0;

}

int main()

{

int a = 10;

int b = 20;

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

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

(a < b ? a : b )= 30;

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

system("pause");

return 0;

}

int main()

{

const int a;

int const b;

const int *c;

int * const d;

const int * const e ;

return 0;

}

Int func1(const )

初级理解：const是定义常量==》const意味着只读

含义：

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

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

//第四个 d 常指针（指针变量不能被修改，但是它所指向内存空间可以被修改）

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

Const好处

//合理的利用const，

//1指针做函数参数，可以有效的提高代码可读性，减少bug；

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

int setTeacher_err( const Teacher *p)

Const修改形参的时候，在利用形参不能修改指针所向的内存空间

int main()

{

const int a = 10;

int *p = (int*)&a; 

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

*p = 11;

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

printf("Hello...... ");

return 0;

}

解释：

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

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

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

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

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

C++中const符号表原理图

注意：

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 ", i, array[i]);

    }

    getchar();

    return 0;

}

C++中的const修饰的，是一个真正的常量，而不是C中变量（只读）。在const修饰的常量编译期间，就已经确定下来了。

对比加深

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

const int c = 5; ≈ #define c 5

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

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

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

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

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

练习

void fun1()

{

    #define a 10

    const int b = 20;

    //#undef a  # undef

}

void fun2()

{

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

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

}

int main()

{

    fun1();

    fun2();

    return 0;

}

void main01()

{

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

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

a =11; //直接赋值

{

int *p = &a;

*p = 12;

printf("a %d ",a);

}

b  = 14;

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

system("pause");

}

问题：C中可以编译通过吗？

int main()

{

int a = 0;

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

     b = 11;  //*b = 11;

return 0;

}

结论：请不要用C的语法考虑 b=11

普通引用在声明时必须用其它的变量进行初始化，

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

//05复杂数据类型 的引用

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 ", t1.age); //33

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

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

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

system("pause");

return ;

}

1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针

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

int main()

{

    int a = 10;

int &b = a;

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

b = 11;

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

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

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

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

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

system("pause");

return 0;

}

单独定义的引用时，必须初始化；说明很像一个常量

struct Teacer {

int &a;

int &b;

};

int main()

{

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

system("pause");

return 0;

}

引用是一个有地址，引用是常量。。。。。

char *const p

int getAA1()

{

int a;

a = 10;

return a;

}

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

int& getAA2()

{

int a;

a = 10;

return a;

}

int* getAA3()

{

int a;

a = 10;

return &a;

}

//static修饰变量的时候，变量是一个状态变量

int j()

{

static int a = 10;

a ++;

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

return a;

}

int& j1()

{

static int a = 10;

a ++;

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

return a;

}

int *j2()

{

static int a = 10;

a ++;

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

return &a;

}

void main22()

{

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

//11 = 100;

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

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

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

j1();

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

j2();

system("pause");

}

int  g1(int *p)

{

*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 ", a1);

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

system("pause");

}

struct Teachar

{

char name[64];

int age;

};

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

struct Teachar & OpTeacher(struct Teachar &t1)

{

}

#include "iostream"

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 ", p->age);

system("pause");

}

思考cost int &a = b PK const int &a = 10;

？？？？问题：const引用，

在C++中可以声明const引用

const Type& name = var；

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

案例1：

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 ", a);

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

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

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

system("pause");

return 0;

}

案例2：

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引用分配内存空间了吗？

void main()

{

const int b = 10;

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

//int &a1 = 19; 如果不加const编译失败

const int &a = 19;

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

system("pause");

}

void main()

{

//普通引用

int a = 10;

int &b = a;

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

const int &c = a;  

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

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

{

int x = 20;

const int& y = x;

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

}

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

{

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

const int &m = 10;

}

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

system("pause");

return ;

}

int& j()

{

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 ", a);

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

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

system("pause");

return 0;

}

C++中的const常量可以替代宏常数定义，如：

const int A = 3; è #define A 3

C++中是否有解决方案替代宏代码片段呢？（替代宏代码片段就可以避免宏的副作用！）

C++中推荐使用内联函数替代宏代码片段

C++中使用inline关键字声明内联函数

内联函数声明时inline关键字必须和函数定义结合在一起，否则编译器会直接忽略内联请求。

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

#include "iostream"

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 ", a);

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

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

system("pause");

return 0;

}

说明1：

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

说明2

C++编译器可以将一个函数进行内联编译

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

内联函数在最终生成的代码中是没有定义的

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

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

说明3：C++编译器不一定准许函数的内联请求！

说明4

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

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

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

宏代码片段 由预处理器处理， 进行简单的文本替换，没有任何编译过程

说明5：

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

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

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

说明6：

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

不能存在任何形式的循环语句    

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

函数体不能过于庞大

不能对函数进行取址操作

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

编译器对于内联函数的限制并不是绝对的，内联函数相对于普通函数的优势只是省去了函数调用时压栈，跳转和返回的开销。

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

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

2）inline只是一种请求，编译器不一定允许这种请求

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

/*1

C++中可以在函数声明时为参数提供一个默认值，

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

*/

void myPrint(int x = 3)

{

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

}

/*2

函数默认参数的规则

只有参数列表后面部分的参数才可以提供默认参数值

一旦在一个函数调用中开始使用默认参数值，那么这个参数后的所有参数都必须使用默认参数值

*/

//默认参数

void printAB(int x = 3)

{

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

}

//在默认参数规则 ，如果默认参数出现，那么右边的都必须有默认参数

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

{

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

}

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

{

printAB(2);

printAB();

system("pause");

return 0;

}

/*

函数占位参数  

占位参数只有参数类型声明，而没有参数名声明

一般情况下，在函数体内部无法使用占位参数

*/

int func(int a, int b, int ) 

{

return a + b;

}

int main01()

{

    //func(1, 2); //可以吗？

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

getchar();

return 0;

}

/*

可以将占位参数与默认参数结合起来使用

意义

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

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

*/

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

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

{

return a + b;

}

void main()

{

//如果默认参数和占位参数在一起，都能调用起来

func2(1, 2);

func2(1, 2, 3);

system("pause");

}

结论：//如果默认参数和占位参数在一起，都能调用起来

1 函数重载概念

函数重载(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 ", c);

c = func(1, 2);

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

c = func("12345");

printf("c = %d ", 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 ", 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 ", c);

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

getchar();

return 0;

}

*/

register：这个关键字请求编译器尽可能的将变量存在CPU内部寄存器中，而不是通过内存寻址访问，以提高效率。注意是尽可能，不是绝对。你想想，一个CPU 的寄存器也就那么几个或几十个，你要是定义了很多很多register 变量，它累死也可能不能全部把这些变量放入寄存器吧，轮也可能轮不到你。

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

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

    好，那我们再联想到我们的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(" a:%d", a);

}

Test5(int a, int b)

{

printf(" a:%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;

}

#include "iostream"

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 ", 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();

} 

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

#include "iostream"

using namespace std;

class Location

{

public:

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

{

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

}

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. " ;

}

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");

}

class Name

{

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 ", a, b, c);

printf("ABC construct .. ");

}

~ABC()

{

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

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

}

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++中的class从面向对象理论出发，将变量(属性)和函数(方法)集中定义在一起，用于描述现实世界中的类。从计算机的角度，程序依然由数据段和代码段构成。

C++编译器如何完成面向对象理论到计算机程序的转化？

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

具体的说：具体对象调用类中的方法，那，c++编译器是如何区分，是那个具体的类，调用这个方法那?

思考一下程序结果

#include "iostream"

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 ", sizeof(C1));

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

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

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

system("pause");

}

通过上面的案例，我们可以的得出：

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

成员变量：

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

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

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

问题出来了：很多对象共用一块代码？代码是如何区分具体对象的那？

换句话说：int getK() const { return k; }，代码是如何区分，具体obj1、obj2、obj3对象的k值？

2）C++编译器对普通成员函数的内部处理

请仔细思考，并说出你的总结！

1、C++类对象中的成员变量和成员函数是分开存储的。C语言中的内存四区模型仍然有效！

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

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

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

静态成员函数不包含指向具体对象的指针

普通成员函数包含一个指向具体对象的指针

class A1

{

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");

}

#include "iostream"

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! " ;  return ; }

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

cout << "saled. " ;

}

void main()

{

Goods * front = NULL , * rear = NULL ;

int  w ;  int  choice ;

do

{

cout << "Please choice: " ;

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

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 "iostream"

#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 ", i, a1.getData(i));

    }

    Array a2 = a1;

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

    {

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

    }

    system("pause");

    return 0;

}

#ifndef _MYARRAY_H_

#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

class Complex

{

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 ;

}

#include <iostream>

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 ! " ; 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 ! " ;  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 : " ;     

cin >> k ;

vector A( k ) ;

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

cin >> A ;

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

cout << A ;

system("pause");

}

//obj3 = obj1;  // C++编译器提供的 等号操作 也属 浅拷贝

// 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 <cstdlib>

#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语言中 没有字符串这种类型，是通过数组来模拟字符串

//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;

};

class Test

{

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(); //重载操作符 ->

};

class MyIntPointer

{

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; //重载*操作符

};

父类成员访问级别

继

承

方

式

public

proteced

private

public

public

proteced

private

proteced

proteced

proteced

private

private

private

private

Private

//类的继承方式对子类对外访问属性影响

#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 <cstdlib>

#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 <cstdlib>

#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;

}

函数重写

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

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

class Parent

{

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静态链编

//工程开发中如何判断是不是多态存在？

/*

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

继承的情况下，发生重写

重载不一定;

重写的定义

静态联编 重载是

动态联编

*/

#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;

}

#include "iostream"

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("英雄打败敌人。。。胜利 ");

}

else

{

printf("英雄。。。牺牲 ");

}

}

void main()

{

HeroFighter hf;

enemyFighter ef;

objPK(&hf, &ef);

AdvHeroFighter advhf;

objPK(&advhf, &ef);

system("pause");

}

1、C++与C相同，是静态编译型语言

2、在编译时，编译器自动根据指针的类型判断指向的是一个什么样的对象；所以编译器认为父类指针指向的是父类对象。

3、由于程序没有运行，所以不可能知道父类指针指向的具体是父类对象还是子类对象

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

多态的实现效果

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

多态实现的三个条件

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

多态的C++实现

   virtual关键字，告诉编译器这个函数要支持多态；不是根据指针类型判断如何调用；而是要根据指针所指向的实际对象类型来判断如何调用
多态的理论基础

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

多态的重要意义

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

实现多态的理论基础 

  函数指针做函数参数

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

多态原理探究

  与面试官展开讨论

#include <cstdlib>

#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函数是什么关系？

C++中多态的实现原理

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

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

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

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

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

说明1：

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

说明2：

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

说明3 ：C++编译器，执行HowToPrint函数，不需要区分是子类对象还是父类对象

#include <iostream>

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()

{

//加上virtual关键字 c++编译器会增加一个指向虚函数表的指针 。。。

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

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

system("pause");

return ;

}

1）对象中的VPTR指针什么时候被初始化？

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

只有当对象的构造完全结束后VPTR的指向才最终确定

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

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

2）分析过程

   画图分析

C++中是否有Java中的接口概念？

绝大多数面向对象语言都不支持多继承

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

C++中没有接口的概念

C++中可以使用纯虚函数实现接口

接口类中只有函数原型定义，没有任何数据的定义。

class Interface  

{

public:

virtual void func1() = 0;

virtual void func2(int i) = 0;

virtual void func3(int i) = 0;

};

实际工程经验证明

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

多重继承可以通过精心设计用单继承和接口来代替

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

子类需要根据功能说明定义功能实现。

#include "iostream"

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语言中的函数有自己特定的类型

C语言中通过typedef为函数类型重命名

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为指向函数的参数类型列表

函数指针语法梳理

//函数类型

//函数指针类型

//函数指针变量

数组指针语法梳理  

//数组类型语法

//数组指针类型

//数组指针变量

typedef int(FUNC)(int);

int test(int i)

{

    return i * i;

}

void f()

{

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

}

int main()

{

    FUNC* pt = test;

    void(*pf)() = &f;

    pf();

    (*pf)();

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

}

1、 指针做函数参数pk函数指针做函数参数

回忆指针做函数参数

一级指针做函数参数、二级。。。。、三级

2、 函数指针做函数参数

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

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

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 的代码作了修改，也不必改动库的代码，就可以正常实现调用

便于程序的维护和升级

1、 函数指针做函数参数，调用方式

被调用函数和主调函数在同一文件中（用来教学，没有任何意义）

2、函数指针做函数参数

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

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

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

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

3、 练习

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. ");

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 ..... ");

}

else

{

printf("edf ok ");

printf("%s ", 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 ", outData);

}

getchar();

}

#include <iostream>

using namespace std;

/*

void myswap(int &a, int &b)

{

int t = a;

a = b;

b = t;

}

void myswap(char &a, char &b)

{

char t = a;

a = b;

b = t;

}

*/

//template 关键字告诉C++编译器 我要开始泛型了.你不要随便报错  

//数据类型T 参数化数据类型

template <typename T>

void myswap(T &a, T &b)

{

T t;

t = a;

a = b;

b = t;

}

void main()

{

//char a = 'c';

int  x = 1;

int  y = 2;

myswap(x, y); //自动数据类型 推导的方式

float a = 2.0;

float b = 3.0;

myswap(a, b); //自动数据类型 推导的方式

myswap<float>(a, b); //显示类型调用

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

system("pause");

return ;

}

#include <iostream>

using namespace std;

template <typename T>

void myswap(T &a, T &b)

{

T t;

t = a;

a = b;

b = t;

cout<<"myswap 模板函数do"<<endl;

}

void myswap(char &a, int &b)

{

int t;

t = a;

a = b;

b = t;

cout<<"myswap 普通函数do"<<endl;

}

void main()

{

char cData = 'a';

int  iData = 2;

//myswap<int>(cData, iData);  //结论 函数模板不提供隐式的数据类型转换  必须是严格的匹配

myswap(cData, iData);

//myswap(iData, cData);

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

system("pause");

return ;

}

#include "iostream"

using namespace std;

int Max(int a, int b)

{

cout<<"int Max(int a, int b)"<<endl;

return a > b ? a : b;

}

template<typename T>

T Max(T a, T b)

{

cout<<"T Max(T a, T b)"<<endl;

return a > b ? a : b;

}

template<typename T>

T Max(T a, T b, T c)

{

cout<<"T Max(T a, T b, T c)"<<endl;

return Max(Max(a, b), c);

}

void main()

{

int a = 1;

int b = 2;

cout<<Max(a, b)<<endl; //当函数模板和普通函数都符合调用时,优先选择普通函数

cout<<Max<>(a, b)<<endl; //若显示使用函数模板,则使用<> 类型列表

cout<<Max(3.0, 4.0)<<endl; //如果 函数模板产生更好的匹配 使用函数模板

cout<<Max(5.0, 6.0, 7.0)<<endl; //重载

cout<<Max('a', 100)<<endl;  //调用普通函数 可以隐式类型转换

system("pause");

return ;

}

gcc（GNU C Compiler）编译器的作者是Richard Stallman，也是GNU项目的奠基者。

什么是gcc：gcc是GNU Compiler Collection的缩写。最初是作为C语言的编译器（GNU C Compiler），现在已经支持多种语言了，如C、C++、Java、Pascal、Ada、COBOL语言等。

gcc支持多种硬件平台，甚至对Don Knuth 设计的 MMIX 这类不常见的计算机都提供了完善的支持

1）gcc是一个可移植的编译器，支持多种硬件平台

2）gcc不仅仅是个本地编译器，它还能跨平台交叉编译。

3）gcc有多种语言前端，用于解析不同的语言。

4）gcc是按模块化设计的，可以加入新语言和新CPU架构的支持

5）gcc是*软件

预处理（Pre-Processing）

编译（Compiling）

汇编（Assembling）

链接（Linking）

Gcc *.c –o 1exe (总的编译步骤)

Gcc –E 1.c –o 1.i  //宏定义 宏展开

Gcc –S 1.i –o 1.s

Gcc –c 1.s –o 1.o  

Gcc 1.o –o 1exe

结论：gcc编译工具是一个工具链。。。。

hello程序是一个高级Ｃ语言程序，这种形式容易被人读懂。为了在系统上运行hello.c程序，每条Ｃ语句都必须转化为低级机器指令。然后将这些指令打包成可执行目标文件格式，并以二进制形式存储器于磁盘中。

选项

作用

-o

产生目标（.i、.s、.o、可执行文件等）

-c

通知gcc取消链接步骤，即编译源码并在最后生成目标文件

-E

只运行C预编译器

-S

告诉编译器产生汇编语言文件后停止编译，产生的汇编语言文件扩展名为.s

-Wall

使gcc对源文件的代码有问题的地方发出警告

-Idir

将dir目录加入搜索头文件的目录路径

-Ldir

将dir目录加入搜索库的目录路径

-llib

链接lib库

-g

在目标文件中嵌入调试信息，以便gdb之类的调试程序调试

gcc -E hello.c -o hello.i（预处理）

gcc -S hello.i -o hello.s（编译）

gcc -c hello.s -o hello.o（汇编）

gcc hello.o -o hello（链接）

以上四个步骤，可合成一个步骤

gcc hello.c -o hello（直接编译链接成可执行目标文件）

gcc -c hello.c或gcc -c hello.c -o hello.o（编译生成可重定位目标文件）

建议初学都加这个选项。下面这个例子如果不加-Wall选项编译器不报任何错误，但是得到的结果却不是预期的。

#include <stdio.h>

int main(void)

{

        printf("2+1 is %f", 3);

        return 0;

}

Gcc编译多个.c

hello_1.h

hello_1.c

main.c

一次性编译

gcc  hello_1.c main.c –o newhello

独立编译

gcc -Wall -c main.c -o main.o

gcc -Wall -c hello_1.c -o hello_fn.o

gcc -Wall main.o hello_1.o -o newhello

.file "7.cpp"

.text

.def __ZL6printfPKcz; .scl 3; .type 32; .endef

__ZL6printfPKcz:

LFB264:

.cfi_startproc

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

pushl %ebx

subl $36, %esp

.cfi_offset 3, -12

leal 12(%ebp), %eax

movl %eax, -12(%ebp)

movl -12(%ebp), %eax

movl %eax, 4(%esp)

movl 8(%ebp), %eax

movl %eax, (%esp)

call ___mingw_vprintf

movl %eax, %ebx

movl %ebx, %eax

addl $36, %esp

popl %ebx

.cfi_restore 3

popl %ebp

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE264:

.lcomm __ZStL8__ioinit,1,1

.def ___main; .scl 2; .type 32; .endef

.section .rdata,"dr"

LC0:

.ascii "a:%d b:%d 12 "

LC1:

.ascii "c1:%c c2:%c 12 "

LC2:

.ascii "pause "

.text

.globl _main

.def _main; .scl 2; .type 32; .endef

_main:

LFB1023:

.cfi_startproc

.cfi_personality 0,___gxx_personality_v0

.cfi_lsda 0,LLSDA1023

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

andl $-16, %esp

subl $32, %esp

call ___main

movl $0, 28(%esp)

movl $10, 24(%esp)

movb $97, 23(%esp)

movb $98, 22(%esp)

leal 24(%esp), %eax

movl %eax, 4(%esp)

leal 28(%esp), %eax

movl %eax, (%esp)

call __Z6myswapIiEvRT_S1_  //66  ===>126 

movl 24(%esp), %edx

movl 28(%esp), %eax

movl %edx, 8(%esp)

movl %eax, 4(%esp)

movl $LC0, (%esp)

call __ZL6printfPKcz

leal 22(%esp), %eax

movl %eax, 4(%esp)

leal 23(%esp), %eax

movl %eax, (%esp)

call __Z6myswapIcEvRT_S1_ //77 ===>155 

movzbl 22(%esp), %eax

movsbl %al, %edx

movzbl 23(%esp), %eax

movsbl %al, %eax

movl %edx, 8(%esp)

movl %eax, 4(%esp)

movl $LC1, (%esp)

call __ZL6printfPKcz

movl $LC2, (%esp)

LEHB0:

call _system

LEHE0:

movl $0, %eax

jmp L7

L6:

movl %eax, (%esp)

LEHB1:

call __Unwind_Resume

LEHE1:

L7:

leave

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE1023:

.def ___gxx_personality_v0; .scl 2; .type 32; .endef

.section .gcc_except_table,"w"

LLSDA1023:

.byte 0xff

.byte 0xff

.byte 0x1

.uleb128 LLSDACSE1023-LLSDACSB1023

LLSDACSB1023:

.uleb128 LEHB0-LFB1023

.uleb128 LEHE0-LEHB0

.uleb128 L6-LFB1023

.uleb128 0

.uleb128 LEHB1-LFB1023

.uleb128 LEHE1-LEHB1

.uleb128 0

.uleb128 0

LLSDACSE1023:

.text

.section .text$_Z6myswapIiEvRT_S1_,"x"

.linkonce discard

.globl __Z6myswapIiEvRT_S1_

.def __Z6myswapIiEvRT_S1_; .scl 2; .type 32; .endef

__Z6myswapIiEvRT_S1_:  //126 

LFB1024:

.cfi_startproc

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

subl $16, %esp

movl 8(%ebp), %eax

movl (%eax), %eax

movl %eax, -4(%ebp)

movl 12(%ebp), %eax

movl (%eax), %edx

movl 8(%ebp), %eax

movl %edx, (%eax)

movl 12(%ebp), %eax

movl -4(%ebp), %edx

movl %edx, (%eax)

leave

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE1024:

.section .text$_Z6myswapIcEvRT_S1_,"x"

.linkonce discard

.globl __Z6myswapIcEvRT_S1_

.def __Z6myswapIcEvRT_S1_; .scl 2; .type 32; .endef

__Z6myswapIcEvRT_S1_: //155 

LFB1025:

.cfi_startproc

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

subl $16, %esp

movl 8(%ebp), %eax

movzbl (%eax), %eax

movb %al, -1(%ebp)

movl 12(%ebp), %eax

movzbl (%eax), %edx

movl 8(%ebp), %eax

movb %dl, (%eax)

movl 12(%ebp), %eax

movzbl -1(%ebp), %edx

movb %dl, (%eax)

leave

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE1025:

.text

.def ___tcf_0; .scl 3; .type 32; .endef

___tcf_0:

LFB1027:

.cfi_startproc

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

subl $8, %esp

movl $__ZStL8__ioinit, %ecx

call __ZNSt8ios_base4InitD1Ev

leave

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE1027:

.def __Z41__static_initialization_and_destruction_0ii; .scl 3; .type 32; .endef

__Z41__static_initialization_and_destruction_0ii:

LFB1026:

.cfi_startproc

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

subl $24, %esp

cmpl $1, 8(%ebp)

jne L11

cmpl $65535, 12(%ebp)

jne L11

movl $__ZStL8__ioinit, %ecx

call __ZNSt8ios_base4InitC1Ev

movl $___tcf_0, (%esp)

call _atexit

L11:

leave

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE1026:

.def __GLOBAL__sub_I_main; .scl 3; .type 32; .endef

__GLOBAL__sub_I_main:

LFB1028:

.cfi_startproc

pushl %ebp

.cfi_def_cfa_offset 8

.cfi_offset 5, -8

movl %esp, %ebp

.cfi_def_cfa_register 5

subl $24, %esp

movl $65535, 4(%esp)

movl $1, (%esp)

call __Z41__static_initialization_and_destruction_0ii

leave

.cfi_restore 5

.cfi_def_cfa 4, 4

ret

.cfi_endproc

LFE1028:

.section .ctors,"w"

.align 4

.long __GLOBAL__sub_I_main

.ident "GCC: (rev2, Built by MinGW-builds project) 4.8.0"

.def ___mingw_vprintf; .scl 2; .type 32; .endef

.def _system; .scl 2; .type 32; .endef

.def __Unwind_Resume; .scl 2; .type 32; .endef

.def __ZNSt8ios_base4InitD1Ev; .scl 2; .type 32; .endef

.def __ZNSt8ios_base4InitC1Ev; .scl 2; .type 32; .endef

.def _atexit; .scl 2; .type 32; .endef

//类的类型参数化 抽象的类

//单个类模板

template<typename T>

class A

{

public:

A(T t)

{

this->t = t;

}

T &getT()

{

return t;

}

protected:

public:

T t;

};

void main()

{

   //模板了中如果使用了构造函数,则遵守以前的类的构造函数的调用规则

A<int>  a(100);

a.getT();

printAA(a);

return ;

}

//结论: 子类从模板类继承的时候,需要让编译器知道 父类的数据类型具体是什么(数据类型的本质:固定大小内存块的别名)A<int>

//

class B : public A<int>

{

public:

B(int i) : A<int>(i)

{

}

void printB()

{

cout<<"A:"<<t<<endl;

}

protected:

private:

};

//模板与上继承

//怎么样从基类继承  

//若基类只有一个带参数的构造函数,子类是如何启动父类的构造函数

void pintBB(B &b)

{

b.printB();

}

void printAA(A<int> &a)  //类模板做函数参数 

{

 //

a.getT();

}

void main()

{

A<int>  a(100); //模板了中如果使用了构造函数,则遵守以前的类的构造函数的调用规则

a.getT();

printAA(a);