1、构造函数、析构函数可以写成虚函数么?

2 篇文章 0 订阅

构造函数:不行

原因:

1、因为创建一个对象时要确定对象的类型,而虚函数是在运行时确定其类型的,而在构造一个对象时,由于对象还未创建成功,编译器无法知道对象的实际类型。

2、虚函数对应一个虚表,可是这个虚表其实是存储在对象的内存空间的。如果构造函数是虚的,就需要通过虚表来调用,可是对象还没有实例化,也就是内存空间还没有,怎么找虚表呢?所以构造函数不能是虚函数。

析构函数:可以

原因:

1、在多态当中,基类的方法被定义成 虚函数,才可以通过基类指针动态调用派生类的方法,同理当我们delete 基类指针,如果基类析构函数不是虚函数,就无法动态调用到派生类的析构函数,导致派生类的对象无法析构,造成内存泄漏。反之,基类析构函数被定义成 虚函数的时候,delete基类指针时,会先 析构派生类对象,再 析构基类对象。

示例:

#include <iostream>
using namespace std;

class FatherA
{
private:
    /* data */
public:
    FatherA(/* args */){}
    ~FatherA()
    {
        cout << "我不是虚函数,正在析构基类FatherA"<<endl;
    }

};

class FatherB
{
private:
    /* data */
public:
    FatherB(/* args */){}
    virtual ~FatherB()
    {
        cout << "我是虚函数,正在析构基类FatherB"<<endl;
    }

};

class Child:public FatherA,public FatherB
{
private:
    /* data */
public:
    Child(/* args */);
    ~Child();
};

Child::Child(/* args */)
{
}

Child::~Child()
{
    cout << "析构派生类child"<<endl;
}

int main()
{
    FatherA *A = new Child();
    FatherB *B = new Child();
    cout<<"start delete A"<<endl;
    delete A;
    cout<<"end delete A"<<endl<<endl;

    cout<<"start delete B"<<endl;
    delete B;
    cout<<"end delete B"<<endl;
    
    return 0;
}

 

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
主体:(一) 一、C++概述 (一) 发展历史 1980年,Bjarne Stroustrup博士开始着手创建一种模拟语言,能够具有面向对象的程序设计特色。在当时,面向对象编程还是一个比较新的理念,Stroustrup博士并不是从头开始设计新语言,而是在C语言的基础上进行创建。这就是C++语言。 1985年,C++开始在外面慢慢流行。经过多年的发展,C++已经有了多个版本。为次,ANSI和ISO的联合委员会于1989年着手为C++制定标准。1994年2月,该委员会出版了第一份非正式草案,1998年正式推出了C++的国际标准。 (二) C和C++ C++是C的超集,也可以说C是C++的子集,因为C先出现。按常理说,C++编译器能够编译任何C程序,但是C和C++还是有一些小差别。 例如C++增加了C不具有的关键字。这些关键字能作为函数和变量的标识符在C程序中使用,尽管C++包含了所有的C,但显然没有任何C++编译器能编译这样的C程序。 C程序员可以省略函数原型,而C++不可以,一个不带参数的C函数原型必须把void写出来。而C++可以使用空参数列表。 C++中new和delete是对内存分配的运算符,取代了C中的malloc和free。 标准C++中的字符串类取代了C标准C函数库头文件中的字符数组处理函数。 C++中用来做控制态输入输出的iostream类库替代了标准C中的stdio函数库。 C++中的try/catch/throw异常处理机制取代了标准C中的setjmp()和longjmp()函数。 二、关键字和变量 C++相对与C增加了一些关键字,如下: typename bool dynamic_cast mutable namespace static_cast using catch explicit new virtual operator false private template volatile const protected this wchar_t const_cast public throw friend true reinterpret_cast try bitor xor_e and_eq compl or_eq not_eq bitand 在C++中还增加了bool型变量和wchar_t型变量: 布尔型变量是有两种逻辑状态的变量,它包含两个值:真和假。如果在表达式中使用了布尔型变量,那么将根据变量值的真假而赋予整型值1或0。要把一个整型变量转换成布尔型变量,如果整型值为0,则其布尔型值为假;反之如果整型值为非0,则其布尔型值为真。布儿型变量在运行时通常用做标志,比如进行逻辑测试以改变程序流程。 #include iostream.h int main() { bool flag; flag=true; if(flag) cout<<true<<endl; return 0; } C++中还包括wchar_t数据类型,wchar_t也是字符类型,但是是那些宽度超过8位的数据类型。许多外文字符集所含的数目超过256个,char字符类型无法完全囊括。wchar_t数据类型一般为16位。 标准C++的iostream类库中包括了可以支持宽字符的类和对象。用wout替代cout即可。 #include iostream.h int main() { wchar_t wc; wc='b'; wout<<wc; wc='y'; wout<<wc; wc='e'; wout<<wc<<endl; return 0; } 说明一下:某些编译器无法编译该程序(不支持该数据类型)。 三、强制类型转换 有时候,根据表达式的需要,某个数据需要被当成另外的数据类型来处理,这时,就需要强制编译器把变量或常数由声明时的类型转换成需要的类型。为此,就要使用强制类型转换说明,格式如下: int* iptr=(int*) &table; 表达式的前缀(int*)就是传统C风格的强制类型转换说明(typecast),又可称为强制转换说明(cast)。强制转换说明告诉编译器把表达式转换成指定的类型。有些情况下强制转换是禁用的,例如不能把一个结构类型转换成其他任何类型。数字类型和数字类型、指针和指针之间可以相互转换。当然,数字类型和指针类型也可以相互转换,但通常认为这样做是不安全而且也是没必要的。强制类型转换可以避免编译器的警告。 long int el=123; short i=(int) el; float m=34.56; int i=(int) m; 上面两个都是C风格的强制类型转换,C++还增加了一种转换方式,比较一下上面和下面这个书写方式的不同: long int el=123; short i=int (el); float m=34.56; int i=int (m); 使用强制类型转换的最大好处就是:禁止编译器对你故意去做的事发出警告。但是,利用强制类型转换说明使得编译器的类型检查机制失效,这不是明智的选择。通常,是不提倡进行强制类型转换的。除非不可避免,如要调用malloc()函数时要用的void型指针转换成指定类型指针。 四、标准输入输出流 在C语言中,输入输出是使用语句scanf()和printf()来实现的,而C++中是使用类来实现的。 #include iostream.h main() //C++中main()函数默认为int型,而C语言中默认为void型。 { int a; cout<>a; /*输入一个数值*/ cout<<a<<endl; //输出并回车换行 return 0; } cin,cout,endl对象,他们本身并不是C++语言的组成部分。虽然他们已经是ANSI标准C++中被定义,但是他们不是语言的内在组成部分。在C++中不提供内在的输入输出运算符,这与其他语言是不同的。输入和输出是通过C++类来实现的,cin和cout是这些类的实例,他们是在C++语言的外部实现。 在C++语言中,有了一种新的注释方法,就是‘//’,在该行//后的所有说明都被编译器认为是注释,这种注释不能换行。C++中仍然保留了传统C语言的注释风格/*……*/。 C++也可采用格式化输出的方法: #include iostream.h int main() { int a; cout<>a; cout<<dec<<a<<' ' //输出十进制数 <<oct<<a<<' ' //输出八进制数 <<hex<<a<<endl; //输出十六进制数 return 0; } 从上面也可以看出,dec,oct,hex也不可作为变量的标识符在程序中出现。 五、函数参数问题 (一) 无名的函数形参 声明函数时可以包含一个或多个用不到的形式参数。这种情况多出现在用一个通用的函数指针调用多个函数的场合,其中有些函数不需要函数指针声明中的所有参数。看下面的例子: int fun(int x,int y) { return x*2; } 尽管这样的用法是正确的,但大多数C和C++的编译器都会给出一个警告,说参数y在程序中没有被用到。为了避免这样的警告,C++允许声明一个无名形参,以告诉编译器存在该参数,且调用者需要为其传递一个实际参数,但是函数不会用到这个参数。下面给出使用了无名参数的C++函数代码: int fun(int x,int) //注意不同点 { return x*2; } (二) 函数的默认参数 C++函数的原型中可以声明一个或多个带有默认值的参数。如果调用函数时,省略了相应的实际参数,那么编译器就会把默认值作为实际参数。可以这样来声明具有默认参数的C++函数原型: #include iostream.h void show(int=1,float=2.3,long=6); int main() { show(); show(2); show(4,5.6); show(8,12.34,50L); return 0; } void show(int first,float second,long third) { cout<<first=<<first <<second=<<second <<third=<<third<<endl; } 上面例子中,第一次调用show()函数时,让编译器自动提供函数原型中指定的所有默认参数,第二次调用提供了第一个参数,而让编译器提供剩下的两个,第三次调用则提供了前面两个参数,编译器只需提供最后一个,最后一个调用则给出了所有三个参数,没有用到默认参数。 六、函数重载 在C++中,允许有相同的函数名,不过它们的参数类型不能完全相同,这样这些函数就可以相互区别开来。而这在C语言中是不允许的。 1.参数个数不同 #include iostream.h void a(int,int); void a(int); int main() { a(5); a(6,7); return 0; } void a(int i) { cout<<i<<endl; //输出5 } void a(int i,int j) { cout<<i<<j<<endl; //输出67 } 2.参数格式不同 #include iostream.h void a(int,int); void a(int,float); int main() { a(5,6); a(6,7.0); return 0; } void a(int i,int j) { cout<<i<<j<<endl; //输出56 } void a(int i,float j) { cout<<i<<j<>a; for(int i=1;i<=10;i++) //C语言中,不允许在这里定义变量 { static int a=0; //C语言中,同一函数块,不允许有同名变量 a+=i; cout<<::a<< <<a<<endl; } return 0; } 八、new和delete运算符 在C++语言中,仍然支持malloc()和free()来分配和释放内存,同时增加了new和delete来管理内存。 1.为固定大小的数组分配内存 #include iostream.h int main() { int *birthday=new int[3]; birthday[0]=6; birthday[1]=24; birthday[2]=1940; cout<<I was born on <<birthday[0]<<'/'<<birthday[1]<<'/'<<birthday[2]<>size; int *array=new int[size]; for(int i=0;i<size;i++) array[i]=rand(); for(i=0;i<size;i++) cout<<'\n'<<array[i]; delete [] array; return 0; } 九、引用型变量 在C++中,引用是一个经常使用的概念。引用型变量是其他变量的一个别名,我们可以认为他们只是名字不相同,其他都是相同的。 1.引用是一个别名 C++中的引用是其他变量的别名。声明一个引用型变量,需要给他一个初始化值,在变量的生存周期内,该值不会改变。& 运算符定义了一个引用型变量: int a; int& b=a; 先声明一个名为a的变量,它还有一个别名b。我们可以认为是一个人,有一个真名,一个外号,以后不管是喊他a还是b,都是叫他这个人。同样,作为变量,以后对这两个标识符操作都会产生相同的效果。 #include iostream.h int main() { int a=123; int& b=a; cout<<a<<','<<b<<endl; //输出123,123 a++; cout<<a<<','<<b<<endl; //输出124,124 b++; cout<<a<<','<<b<等运算符 #include iostream.h void func1(s p); void func2(s& p); struct s { int n; char text[10]; }; int main() { static s str={123,China}; func1(str); func2(str); return 0; } void func1(s p) { cout<<p.n<<endl; cout<<p.text<<endl; } void func2(s& p) { cout<<p.n<<endl; cout<<p.text<<endl; } 从表面上看,这两个函数没有明显区别,不过他们所花的时间却有很大差异,func2()函数所用的时间开销会比func2()函数少很多。它们还有一个差别,如果程序递归func1(),随着递归的深入,会因为栈的耗尽而崩溃,但func2()没有这样的担忧。 4.以引用方式调用 当函数把引用作为参数传递给另一个函数时,被调用函数将直接对参数在调用者中的拷贝进行操作,而不是产生一个局部的拷贝(传递变量本身是这样的)。这就称为以引用方式调用。把参数的值传递到被调用函数内部的拷贝中则称为以传值方式调用。 #include iostream.h void display(const Date&,const char*); void swapper(Date&,Date&); struct Date { int month,day,year; }; int main() { static Date now={2,23,90}; static Date then={9,10,60}; display(now,Now: ); display(then,Then: ); swapper(now,then); display(now,Now: ); display(then,Then: ); return 0; } void swapper(Date& dt1,Date& dt2) { Date save; save=dt1; dt1=dt2; dt2=save; } void display(const Date& dt,const char *s) { cout<<s; cout<<dt.month<<'/'<<dt.day<<'/'<<dt.year<<endl; } 5.以引用作为返回值 #include iostream.h struct Date { int month,day,year; }; Date birthdays[]= { {12,12,60}; {10,25,85}; {5,20,73}; }; const Date& getdate(int n) { return birthdays[n-1]; } int main() { int dt=1; while(dt!=0) { cout<<Enter date # (1-3,0 to quit)<>dt; if(dt>0 && dt<4) { const Date& bd=getdate(dt); cout<<bd.month<<'/'<<bd.day<<'/'<<bd.year<<endl; } } return 0; } 程序都很简单,就不讲解了。 主体:(二)类的设计,构造函数析构函数 类是编程人员表达自定义数据类型的C++机制。它和C语言中的结构类似,C++类支持数据抽象和面向对象的程序设计,从某种意义上说,也就是数据类型的设计和实现。 一、类的设计 1.类的声明 class 类名 { private: //私有 ... public: //公有 ... }; 2.类的成员 一般在C++类中,所有定义的变量和函数都是类的成员。如果是变量,我们就叫它数据成员如果是函数,我们就叫它成员函数。 3.类成员的可见性 private和public访问控制符决定了成员的可见性。由一个访问控制符设定的可访问状态将一直持续到下一个访问控制符出现,或者类声明的结束。私有成员仅能被同一个类中的成员函数访问,公有成员既可以被同一类中的成员函数访问,也可以被其他已经实例化的类中函数访问。当然,这也有例外的情况,这是以后要讨论的友元函数。 类中默认的数据类型是private,结构中的默认类型是public。一般情况下,变量都作为私有成员出现,函数都作为公有成员出现。 类中还有一种访问控制符protected,叫保护成员,以后再说明。 4.初始化 在声明一个类的对象时,可以用圆括号()包含一个初始化表。 看下面一个例子: #include iostream.h class Box { private: int height,width,depth; //3个私有数据成员 public: Box(int,int,int); ~Box(); int volume(); //成员函数 }; Box::Box(int ht,int wd,int dp) { height=ht; width=wd; depth=dp; } Box::~Box() { //nothing } int Box::volume() { return height*width*depth; } int main() { Box thisbox(3,4,5); //声明一个类对象并初始化 cout<<thisbox.volume()<<endl; return 0; } 当一个类中没有private成员和protected成员时,也没有虚函数,并且不是从其他类中派生出来的,可以用{}来初始化。(以后再讲解) 5.内联函数 内联函数和普通函数的区别是:内联函数是在编译过程中展开的。通常内联函数必须简短。定义类的内联函数有两种方法:一种和C语言一样,在定义函数时使用关键字inline。如: inline int Box::volume() { return height*width*depth; } 还有一种方法就是直接在类声明的内部定义函数体,而不是仅仅给出一个函数原型。我们把上面的函数简化一下: #include iostream.h class Box { private: int height,width,depth; public: Box(int ht,int wd,int dp) { height=ht; width=wd; depth=dp; } ~Box(); int volume() { return height*width*depth; } }; int main() { Box thisbox(3,4,5); //声明一个类对象并初始化 cout<<thisbox.volume()<<endl; return 0; } 这样,两个函数都默认为内联函数了。 二、构造函数 什么是构造函数?通俗的讲,在类中,函数名和类名相同的函数称为构造函数。上面的Box()函数就是构造函数C++允许同名函数,也就允许在一个类中有多个构造函数。如果一个都没有,编译器将为该类产生一个默认的构造函数,这个构造函数可能会完成一些工作,也可能什么都不做。 绝对不能指定构造函数的类型,即使是void型都不可以。实际上构造函数默认为void型。 当一个类的对象进入作用域时,系统会为其数据成员分配足够的内存,但是系统不一定将其初始化。和内部数据类型对象一样,外部对象的数据成员总是初始化为0。局部对象不会被初始化。构造函数就是被用来进行初始化工作的。当自动类型的类对象离开其作用域时,所站用的内存将释放回系统。 看上面的例子,构造函数Box()函数接受三个整型擦黑素,并把他们赋值给立方体对象的数据成员。 如果构造函数没有参数,那么声明对象时也不需要括号。 1.使用默认参数的构造函数 当在声明类对象时,如果没有指定参数,则使用默认参数来初始化对象。 #include iostream.h class Box { private: int height,width,depth; public: Box(int ht=2,int wd=3,int dp=4) { height=ht; width=wd; depth=dp; } ~Box(); int volume() { return height*width*depth; } }; int main() { Box thisbox(3,4,5); //初始化 Box defaulbox; //使用默认参数 cout<<thisbox.volume()<<endl; //输出60 cout<<defaulbox.volume()<<endl; //输出24 return 0; } 2.默认构造函数 没有参数或者参数都是默认值的构造函数称为默认构造函数。如果你不提供构造函数,编译器会自动产生一个公共的默认构造函数,这个构造函数什么都不做。如果至少提供一个构造函数,则编译器就不会产生默认构造函数。 3.重载构造函数 一个类中可以有多个构造函数。这些构造函数必须具有不同的参数表。在一个类中需要接受不同初始化值时,就需要编写多个构造函数,但有时候只需要一个不带初始值的空的Box对象。 #include iostream.h class Box { private: int height,width,depth; public: Box() { //nothing } Box(int ht=2,int wd=3,int dp=4) { height=ht; width=wd; depth=dp; } ~Box(); int volume() { return height*width*depth; } }; int main() { Box thisbox(3,4,5); //初始化 Box otherbox; otherbox=thisbox; cout<<otherbox.volume();<<endl; return 0; } 这两个构造函数一个没有初始化值,一个有。当没有初始化值时,程序使用默认值,即2,3,4。 但是这样的程序是不好的。它允许使用初始化过的和没有初始化过的Box对象,但它没有考虑当thisbox给otherbox赋值失败后,volume()该返回什么。较好的方法是,没有参数表的构造函数也把默认值赋值给对象。 class Box { int height,width,depth; public: Box() { height=0;width=0;depth=0; } Box(int ht,int wd,int dp) { height=ht;width=wd;depth=dp; } int volume() { return height*width*depth; } }; 这还不是最好的方法,更好的方法是使用默认参数,根本不需要不带参数的构造函数。 class Box { int height,width,depth; public: Box(int ht=0,int wd=0,int dp=0) { height=ht;width=wd;depth=dp; } int volume() { return height*width*depth; } }; 三、析构函数 当一个类的对象离开作用域时,析构函数将被调用(系统自动调用)。析构函数的名字和类名一样,不过要在前面加上 ~ 。对一个类来说,只能允许一个析构函数析构函数不能有参数,并且也没有返回值。析构函数的作用是完成一个清理工作,如释放从堆中分配的内存。 我们也可以只给出析构函数的形式,而不给出起具体函数体,其效果是一样的,如上面的例子。但在有些情况下,析构函数又是必需的。如在类中从堆中分配了内存,则必须在析构函数中释放 主体:(三)类的转换 C++的内部数据类型遵循隐式类型转换规则。假设某个表达市中使用了一个短整型变量,而编译器根据上下文认为这儿需要是的长整型,则编译器就会根据类型转换规则自动把它转换成长整型,这种隐式转换出现在赋值、参数传递、返回值、初始化和表达式中。我们也可以为类提供相应的转换规则。 对一个类建立隐式转换规则需要构造一个转换函数,该函数作为类的成员,可以把该类的对象和其他数据类型的对象进行相互转换。声明了转换函数,就告诉了编译器,当根据句法判定需要类型转换时,就调用函数。 有两种转换函数。一种是转换构造函数;另一种是成员转换函数。需要采用哪种转换函数取决于转换的方向。 一、转换构造函数 当一个构造函数仅有一个参数,且该参数是不同于该类的一个数据类型,这样的构造函数就叫转换构造函数。转换构造函数把别的数据类型的对象转换为该类的一个对象。和其他构造函数一样,如果声明类的对象的初始化表同转换构造函数的参数表相匹配,该函数就会被调用。当在需要使用该类的地方使用了别的数据类型,便宜器就会调用转换构造函数进行转换。 #include iostream.h #include time.h #include stdio.h class Date { int mo, da, yr; public: Date(time_t); void display(); }; void Date::display() { char year[5]; if(yr<10) sprintf(year,0%d,yr); else sprintf(year,%d,yr); cout<<mo<<'/'<<da<<'/'<tm_mday; mo=tim->tm_mon+1; yr=tim->tm_year; if(yr>=100) yr-=100; } int main() { time_t now=time(0); Date dt(now); dt.display(); return 0; } 本程序先调用time()函数来获取当前时间,并把它赋给time_t对象;然后程序通过调用Date类的转换构造函数来创建一个Date对象,该对象由time_t对象转换而来。time_t对象先传递给localtime()函数,然后返回一个指向tm结构(time.h文件中声明)的指针,然后构造函数把结构中的日月年的数值拷贝给Date对象的数据成员,这就完成了从time_t对象到Date对象的转换。 二、成员转换函数 成员转换函数把该类的对象转换为其他数据类型的对象。在成员转换函数的声明中要用到关键字operator。这样声明一个成员转换函数: operator aaa(); 在这个例子中,aaa就是要转换成的数据类型的说明符。这里的类型说明符可以是任何合法的C++类型,包括其他的类。如下来定义成员转换函数; Classname::operator aaa() 类名标识符是声明了该函数的类的类型说明符。上面定义的Date类并不能把该类的对象转换回time_t型变量,但可以把它转换成一个长整型值,计算从2000年1月1日到现在的天数。 #include iostream.h class Date { int mo,da,yr; public: Date(int m,int d,int y) {mo=m; da=d; yr=y;} operator int(); //声明 }; Date::operator int() //定义 { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; int days=yr-2000; days*=365; days+=(yr-2000)/4; for(int i=0;i<mo-1;i++) days+=dys[i]; days+=da; return days; } int main() { Date now(12,24,2003); int since=now; cout<<since<<endl; return 0; } 三、类的转换 上面两个例子都是C++类对象和内部数据对象之间的相互转换。也可以定义转换函数来实现两个类对象之间的相互转换。 #include iostream.h class CustomDate { public: int da, yr; CustomDate(int d=0,int y=0) {da=d; yr=y;} void display() { cout<<yr<<'-'<<da<<endl; } }; class Date { int mo, da, yr; public: Date(int m=0,int d=0,int y=0) {mo=m; da=d; yr=y;} Date(const CustomDate&); //转换构造函数 operator CustomDate(); //成员转换函数 void display() { cout<<mo<<'/'<<da<<'/'<<yr<<endl; } }; static int dys[] = {31,28,31,30,31,30,31,31,30,31,30,31}; Date::Date(const CustomDate& jd) { yr=jd.yr; da=jd.da; for(mo=0;modys[mo]) da-=dys[mo]; else break; mo++; } Date::operator CustomDate() { CustomDate cd(0,yr); for(int i=0;i<mo-1;i++) cd.da+=dys[i]; cd.da+=da; return cd; } int main() { Date dt(12,24,3); CustomDate cd; cd = dt; //调用成员转换函数 cd.display(); dt = cd; //调用转换构造函数 dt.display(); return 0; } 这个例子中有两个类CustomDate和Date,CustomDate型日期包含年份和天数。 这个例子没有考虑闰年情况。但是在实际构造一个类时,应该考虑到所有问题的可能性。 在Date里中具有两种转换函数,这样,当需要从Date型变为CustomDate型十,可以调用成员转换函数;反之可以调用转换构造函数不能既在Date类中定义成员转换函数,又在CustomDate类里定义转换构造函数。那样编译器在进行转换时就不知道该调用哪一个函数,从而出错。 四、转换函数的调用 C++里调用转换函数有三种形式:第一种是隐式转换,例如编译器需要一个Date对象,而程序提供的是CustomDate对象,编译器会自动调用合适的转换函数。另外两种都是需要在程序代码中明确给出的显式转换。C++强制类型转换是一种,还有一种是显式调用转换构造函数和成员转换函数。下面的程序给出了三中转换形式: #include iostream.h class CustomDate { public: int da, yr; CustomDate(int d=0,int y=0) {da=d; yr=y;} void display() { cout<<yr<<'-'<<da<<endl; } }; class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator CustomDate(); }; Date::operator CustomDate() { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; CustomDate cd(0,yr); for(int i=0;i<mo-1;i++) cd.da+=dys[i]; cd.da+=da; return cd; } int main() { Date dt(11,17,89); CustomDate cd; cd = dt; cd.display(); cd = (CustomDate) dt; cd.display(); cd = CustomDate(dt); cd.display(); return 0; } 五、转换发生的情形 上面的几个例子都是通过不能类型对象之间的相互赋值来调用转换函数,还有几种调用的可能: 参数传递 初始化 返回值 表达式语句 这些情况下,都有可能调用转换函数。 下面的程序不难理解,就不分析了。 #include iostream.h class CustomDate { public: int da, yr; CustomDate() {} CustomDate(int d,int y) { da=d; yr=y;} void display() { cout<<yr<<'-'<<da<<endl; } }; class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator CustomDate(); }; Date::operator CustomDate() { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; CustomDate cd(0,yr); for (int i=0;i<mo-1;i++) cd.da += dys[i]; cd.da+=da; return cd; } class Tester { CustomDate cd; public: explicit Tester(CustomDate c) { cd=c; } void display() { cd.display(); } }; void dispdate(CustomDate cd) { cd.display(); } CustomDate rtndate() { Date dt(9,11,1); return dt; } int main() { Date dt(12,24,3); CustomDate cd; cd = dt; cd.display(); dispdate(dt); Tester ts(dt); ts.display(); cd = rtndate(); cd.display(); return 0; } 六、显式构造函数 注意上面Tester类的构造函数前面有一个explicit修饰符。如果不加上这个关键字,那么在需要把CustomDate对象转换成Tester对象时,编译器会把该函数当作转换构造函数来调用。但是有时候,并不想把这种只有一个参数的构造函数用于转换目的,而仅仅希望用它来显式地初始化对象,此时,就需要在构造函数前加explicit。如果在声明了Tester对象以后使用了下面的语句将导致一个错误: ts=jd; //error 这个错误说明,虽然Tester类中有一个以Date型变量为参数的构造函数,编译器却不会把它看作是从Date到Tester的转换构造函数,因为它的声明中包含了explicit修饰符。 七、表达式内部的转换 在表达式内部,如果发现某个类型和需要的不一致,就会发生错误。数字类型的转换是很简单,这里就不举例了。下面的程序是把Date对象转换成长整型值。 #include iostream.h class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator long(); }; Date::operator long() { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; long days=yr; days*=365; days+=(yr-1900)/4; //从1900年1月1日开始计算 for(int i=0;i<mo-1;i++) days+=dys[i]; days+=da; return days; } int main() { Date today(12,24,2003); const long ott=123; long sum=ott+today; cout<<ott<< + <<(long) today<< = <<sum; return 0; } 在表达式中,当需要转换的对象可以转换成某个数字类型,或者表达式调用了作用于某个类的重载运算符时,就会发生隐式转换。运算符重载以后再学习。 主体:(四)私有数据成员和友元 一、私有数据成员的使用 1.取值和赋值成员函数 面向对象的约定就是保证所有数据成员的私有性。一般我们都是通过公有成员函数来作为公共接口来读取私有数据成员的。某些时候,我们称这样的函数为取值和赋值函数。 取值函数的返回值和传递给赋值函数的参数不必一一匹配所有数据成员的类型。 #include iostream.h class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } int getyear() const { return yr; } void setyear(int y) { yr = y; } }; int main() { Date dt(4,1,89); cout<<The year is: <<dt.getyear()<<endl; dt.setyear(97); cout<<The new year is: <<dt.getyear(); return 0; } 上面的例子很简单,不分析了。要养成这样的习惯,通过成员函数来访问和改变类中的数据。这样有利于软件的设计和维护。比如,改变Date类内部数据的形式,但仍然用修改过的getyear()和setyear()来提供访问接口,那么使用该类就不必修改他们的代码,仅需要重新编译程序即可。 2.常量成员函数 注意上面的程序中getyear()被声明为常量型,这样可以保证该成员函数不会修改调用他的对象。通过加上const修饰符,可以使访问对象数据的成员函数仅仅完成不会引起数据变动的那些操作。 如果程序声明某个Date对象为常量的话,那么该对象不得调用任何非常量型成员函数,不论这些函数是否真的试图修改对象的数据。只有把那些不会引起数据改变的函数都声明为常量型,才可以让常量对象来调用。 3.改进的成员转换函数 下面的程序改进了从Date对象到CustomDate对象的成员转换函数,用取值和赋值函数取代了使用公有数据成员的做法。(以前的程序代码在上一帖中) #include iostream.h class CustomDate { int da,yr; public: CustomDate() {} CustomDate(int d,int y) { da=d; yr=y; } void display() const {cout<<yr<<'-'<<da<<endl;} int getday() const { return da; } void setday(int d) { da=d; } }; class Date { int mo,da,yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator CustomDate() const; }; Date::operator CustomDate() const { static int dys[] = {31,28,31,30,31,30,31,31,30,31,30,31}; CustomDate cd(0,yr); int day=da; for(int i=0;i<mo-1;i++) day+=dys[i]; cd.setday(day); return cd; } int main() { Date dt(11,17,89); CustomDate cd; cd=dt; cd.display(); return 0; } 注意上面的程序中Date::operator CustomDate()声明为常量型,因为这个函数没有改变调用它对象的数据,尽管它修改了一个临时CustomDate对象并将其作为函数返回值。 二、友元 前面已经说过了,私有数据成员不能被类外的其他函数读取,但是有时候类会允许一些特殊的函数直接读写其私有数据成员。 关键字friend可以让特定的函数或者别的类的所有成员函数对私有数据成员进行读写。这既可以维护数据的私有性,有可以保证让特定的类或函数能够直接访问私有数据。 1.友元类 一个类可以声明另一个类为其友元,这个友元的所有成员函数都可以读写它的私有数据。 #include iostream.h class Date; class CustomDate { int da,yr; public: CustomDate(int d=0,int y=0) { da=d; yr=y; } void display() const {cout<<yr<<'-'<<da<<endl;} friend Date; //这儿 }; class Date { int mo,da,yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator CustomDate(); }; Date::operator CustomDate() { static int dys[] = {31,28,31,30,31,30,31,31,30,31,30,31}; CustomDate cd(0, yr); for (int i=0;i<mo-1;i++) cd.da+=dys[i]; cd.da+=da; return cd; } int main() { Date dt(11,17,89); CustomDate cd(dt); cd.display(); return 0; } 在上面的程序中,有这样一句 friend Date; 该语句告诉编译器,Date类的所有成员函数有权访问CustomDate类的私有成员。因为Date类的转换函数需要知道CustomDate类的每个数据成员,所以真个Date类都被声明为CustomDate类的友元。 2.隐式构造函数 上面程序对CustomDate的构造函数的调用私有显示该类需要如下的一个转换构造函数: CustomDate(Date& dt); 但是唯一的一个构造函数是:CustomDate(int d=0;int y=0); 这就出现了问题,编译器要从Date对象构造一个CustomDate对象,但是CustomDate类中并没有定义这样的转换构造函数。不过Date类中定义了一个成员转换函数,它可以把Date对象转换成CustomDate对象。于是编译器开始搜索CustomDate类,看其是否有一个构造函数,能从一个已存在的CustomDate的对象创建新的CustomDate对象。这种构造函数叫拷贝构造函数。拷贝构造函数也只有一个参数,该参数是它所属的类的一个对象,由于CustomDate类中没有拷贝构造函数,于是编译器就会产生一个默认的拷贝构造函数,该函数简单地把已存在的对象的每个成员拷贝给新对象。现在我们已经知道,编译器可以把Date对象转换成CustomDate对象,也可以从已存在的CustomDate对象生成一个新的CustomDate对象。那么上面提出的问题,编译器就是这样做的:它首先调用转换函数,从Date对象创建一个隐藏的、临时的、匿名的CustomDate对象,然后用该临时对象作为参数调用默认拷贝构造函数,这就生成了一个新的CustomDate对象。 3.预引用 上面的例子中还有这样一句 class Date; 这个语句叫做预引用。它告诉编译器,类Date将在后面定义。编译器必须知道这个信号,因为CustomDate类中引用了Date类,而Date里也引用了CustomDate类,必须首先声明其中之一。 使用了预引用后,就可以声明未定义的类的友元、指针和引用。但是不可以使用那些需要知道预引用的类的定义细节的语句,如声明该类的一个实例或者任何对该类成员的引用。 4.显式友元预引用 也可以不使用预引用,这只要在声明友元的时候加上关键自class就行了。 #include iostream.h class CustomDate { int da,yr; public: CustomDate(int d=0,int y=0) { da=d; yr=y; } void display() const {cout<<yr<<'-'<<da<<endl;} friend class Date; //这儿,去掉前面的预引用 }; class Date { ... ... }; Date::operator CustomDate() { ... ... } int main() { ... ... } 5.友元函数 通常,除非真的需要,否则并不需要把整个类都设为另一个类的友元,只需挑出需要访问当前类私有数据成员的成员函数,将它们设置为该类的友元即可。这样的函数称为友元函数。 下面的程序限制了CustomDate类数据成员的访问,Date类中只有需要这些数据的成员函数才有权读写它们。 #include iostream.h class CustomDate; class Date { int mo,da,yr; public: Date(const CustomDate&); void display() const {cout<<mo<<'/'<<da<<'/'<<yr<<endl;} }; class CustomDate { int da,yr; public: CustomDate(int d=0,int y=0) { da=d; yr=y; } friend Date::Date(const CustomDate&); }; Date::Date(const CustomDate& cd) { static int dys[] = {31,28,31,30,31,30,31,31,30,31,30,31}; yr=cd.yr; da=cd.da; for(mo=0;modys[mo]) da-=dys[mo]; else break; mo++; } int main() { Date dt(CustomDate(123, 89)); dt.display(); return 0; } 6.匿名对象 上面main()函数中Date对象调用CustomDate类的构造函数创建了一个匿名CustomDate对象,然后用该对象创建了一个Date对象。这种用法在C++中是经常出现的。 7.非类成员的友元函数 有时候友元函数未必是某个类的成员。这样的函数拥有类对象私有数据成员的读写权,但它并不是任何类的成员函数。这个特性在重载运算符时特别有用。 非类成员的友元函数通常被用来做为类之间的纽带。一个函数如果被两个类同时声明为友元,它就可以访问这两个类的私有成员。下面的程序说明了一个可以访问两个类私有数据成员的友元函数是如何将在两个类之间架起桥梁的。 #include iostream.h class Time; class Date { int mo,da,yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y;} friend void display(const Date&, const Time&); }; class Time { int hr,min,sec; public: Time(int h,int m,int s) { hr=h; min=m; sec=s;} friend void display(const Date&, const Time&); }; void display(const Date& dt, const Time& tm) { cout << dt.mo << '/' << dt.da << '/' << dt.yr; cout << ' '; cout << tm.hr << ':' << tm.min << ':' << tm.sec; } int main() { Date dt(2,16,97); Time tm(10,55,0); display(dt, tm); return 0; } 主体:(五)析构函数和this指针 一、析构函数 前面的一些例子都没有说明析构函数,这是因为所用到的类在结束时不需要做特别的清理工作。下面的程序给出了一新的Date类,其中包括一个字符串指针,用来表示月份。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void display() const; }; Date::Date(int m,int d,int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo=m; da=d; yr=y; if(m!=0) { month=new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if(month!=0) cout<<month<<' '<<da<<','<<yr; } int main() { Date birthday(8,11,1979); birthday.display(); return 0; } 在Date对象的构造函数中,首先用new运算符为字符串month动态分配了内存,然后从内部数组中把月份的名字拷贝给字符串指针month。 析构函数在删除month指针时,可能会出现一些问题。当然从这个程序本身来看,没什么麻烦;但是从设计一个类的角度来看,当Date类用于赋值时,就会出现问题。假设上面的main()修改为“ int main() { Date birthday(8,11,1979); Date today; today=birthday; birthday.display(); return 0; } 这会生成一个名为today的空的Date型变量,并且把birthday值赋给它。如果不特别通知编译器,它会简单的认为类的赋值就是成员对成员的拷贝。在上面的程序中,变量birthday有一个字符型指针month,并且在构造函数里用new运算符初始化过了。当birthday离开其作用域时,析构函数会调用delete运算符来释放内存。但同时,当today离开它的作用域时,析构函数同样会对它进行释放操作,而today里的month指针是birthday里的month指针的一个拷贝。析构函数对同一指针进行了两次删除操作,这会带来不可预知的后果。 如果假设today是一个外部变量,而birthday是一个自变量。当birthday离开其作用域时,就已经把对象today里的month指针删除了。显然这也是不正确的。 再假设有两个初始化的Date变量,把其中一个的值赋值给另一个: Date birthday(8,11,1979); Date today(12,29,2003); today=birthday; 问题就更复杂了,当这两个变量离开作用域时,birthday中的month的值已经通过赋值传递给了today。而today中构造函数用new运算符给month的值却因为赋值被覆盖了。这样,birthday中的month被删除了两次,而today中month却没有被删除掉。 二、重载赋值运算符 为了解决上面的问题,我们应该写一个特殊的赋值运算符函数来处理这类问题。当需要为同一个类的两个对象相互赋值时,就可以重载运算符函数。这个方法可以解决类的赋值和指针的释放。 下面的程序中,类中的赋值函数用new运算符从堆中分配了一个不同的指针,该指针获取赋值对象中相应的值,然后拷贝给接受赋值的对象。 在类中重载赋值运算符的格式如下: void operator = (const Date&) 后面我们回加以改进。目前,重载的运算符函数的返回类型为void。它是类总的成员函数,在本程序红,是Date类的成员函数。它的函数名始终是operator =,参数也始终是同一个类的对象的引用。参数表示的是源对象,即赋值数据的提供者。重载函数的运算符作为目标对象的成员函数来使用。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void operator=(const Date&); void display() const; }; Date::Date(int m, int d, int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo = m; da = d; yr = y; if (m != 0) { month = new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if (month!=0) cout<<month<<' '<<da<<,<<yr<<endl; } void Date::operator=(const Date& dt) { if (this != &dt) { mo = dt.mo; da = dt.da; yr = dt.yr; delete [] month; if (dt.month != 0) { month = new char [std::strlen(dt.month)+1]; std::strcpy(month, dt.month); } else month = 0; } } int main() { Date birthday(8,11,1979); birthday.display(); Date newday(12,29,2003); newday.display(); newday = birthday; newday.display(); return 0; } 除了为Date类加入了一个重载运算符函数,这个程序和上面的一个程序是相同的。赋值运算符函数首先取得所需的数据,然后用delete把原来的month指针所占用的内存返还给堆。接着,如果源对象的month指针已经初始化过,就用new运算符为对象重新分配内存,并把源对象的month字符串拷贝给接受方。 重载的Date类赋值运算符函数的第一个语句比较了源对象的地址和this指针。这个操作取保对象不会自己给自己赋值。 三、this指针 this指针是一个特殊的指针,当类的某个非静态的成员函数在执行时,就会存在this指针。它指向类的一个对象,且这个对象的某个成员函数正在被调用。 this指针的名字始终是this,而且总是作为隐含参数传递给每一个被声明的成员函数,例如: void Date::myFunc(Date* this); 实际编程时函数的声明不需要包含这个参数。 当程序中调用某个对象的成员函数时,编译器会把该对象的地址加入到参数列表中,感觉上就好象函数采用了上面所示的声明,并且是用如下方式来调用的: dt.myFunc(& dt); 静态成员函数不存在this指针。 当调用某个对象的成员函数时,编译器把对象的地址传递给this指针,然后再调用该函数。因此,成员函数你对任何成员的调用实际上都隐式地使用了this指针。 1.以this指针作为返回值 使用this指针可以允许成员函数返回调用对象给调用者。前面的程序中重载赋值运算符没有返回值,因此不能用如下的形式对字符串进行赋值: a=b=c; 为了使重载的类赋值机制也能这样方便,必须让赋值函数返回赋值的结果,在这里就是目标对象。当赋值函数执行时,其返回值也恰好是this指针所指的内容。 下面的程序对前面那个程序进行了修改,让重载赋值运算符返回了一个Date对象的引用。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void operator=(const Date&); void display() const; }; Date::Date(int m, int d, int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo = m; da = d; yr = y; if (m != 0) { month = new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if (month!=0) cout<<month<<' '<<da<<,<<yr<<endl; } void Date::operator=(const Date& dt) { if (this != &dt) { mo = dt.mo; da = dt.da; yr = dt.yr; delete [] month; if (dt.month != 0) { month = new char [std::strlen(dt.month)+1]; std::strcpy(month, dt.month); } else month = 0; } return *this; } int main() { Date birthday(8,11,1979); Date oldday,newday; oldday=newday=birthday; birthday.display(); oldday.display(); newday.display(); return 0; } 2.在链表中使用this指针 在应用程序中,如果数据结构里有指向自身类型的成员,那么使用this指针会提供更多的方便。下面的程序中建立了一个类ListEntry的链表。 #include iostream.h #include string.h class ListEntry { char* listvalue; ListEntry* preventry; public: ListEntry(char*); ~ListEntry() { delete [] listvalue; } ListEntry* PrevEntry() const { return preventry; }; void display() const { cout<<endl<<listvalue; } void AddEntry(ListEntry& le) { le.preventry = this; } }; ListEntry::ListEntry(char* s) { listvalue = new char[strlen(s)+1]; strcpy(listvalue, s); preventry = 0; } int main() { ListEntry* prev = 0; while (1) { cout <<endl<> name; if (strncmp(name, end, 3) == 0) break; ListEntry* list = new ListEntry(name); if (prev != 0) prev->AddEntry(*list); prev = list; } while (prev != 0) { prev->display(); ListEntry* hold = prev; prev = prev->PrevEntry(); delete hold; } return 0; } 程序运行时,会提示输入一串姓名,当输入完毕后,键入end,然后程序会逆序显示刚才输入的所有姓名。 程序中ListEntry类含有一个字符串和一个指向前一个表项的指针。构造函数从对中获取内存分配给字符串,并把字符串的内容拷贝到内存,然后置链接指针为NULL。析构函数将释放字符串所占用的内存。 成员函数PrevEntry()返回指向链表前一个表项的指针。另一个成员函数显示当前的表项内容。 成员函数AddEntry(),它把this指针拷贝给参数的preventry指针,即把当前表项的地址赋值给下一个表项的链接指针,从而构造了一个链表。它并没有改变调用它的listEntry对象的内容,只是把该对象的地址赋给函数的参数所引用的那个ListEntry对象的preventry指针,尽管该函数不会修改对象的数据,但它并不是常量型。这是因为,它拷贝对象的地址this指针的内容给一个非长常量对象,而编译器回认为这个非常量对象就有可能通过拷贝得到的地址去修改当前对象的数据,因此AddEntry()函数在声明时不需要用const。 主体:(六)类对象数组和静态成员 一、类对象数组 类的对象和C++其他数据类型一样,也可以为其建立数组,数组的表示方法和结构一样。 #include iostream.h class Date { int mo,da,yr; public: Date(int m=0,int d=0, int y=0) { mo=m; da=d; yr=y;} void display() const { cout<<mo<<'/'<<da<<'/'<<yr<<endl; } }; int main() { Date dates[2]; Date today(12,31,2003); dates[0]=today; dates[0].display(); dates[1].display(); return 0; } 1.类对象数组和默认构造函数 在前面已经说过,不带参数或者所有参数都有默认值的构造函数叫做默认构造函数。如果类中没有构造函数,编译器会自动提供一个什么都不做的公共默认构造函数 。如果类当中至少有一个构造函数,编译器就不会提供默认构造函数。 如果类当中不含默认构造函数,则无法实例化其对象数组。因为实例花类对象数组的格式不允许用初始化值来匹配某个构造函数的参数表。 上面的程序中,main()函数声明了一个长度为2的Date对象数组,还有一个包含初始化值的单个Date对象。接着把这个初始化的Date对象赋值给数组中第一个对象,然后显示两个数组元素中包含的日期。从输出中可以看到,第一个日期是有效日期,而第二个显示的都是0。 当声明了某个类的对象数组时,编译器会为每个元素都调用默认构造函数。 下面的程序去掉了构造函数的默认参数值,并且增加了一个默认构造函数。 #include class Date { int mo, da, yr; public: Date(); Date(int m,int d,int y) { mo=m; da=d; yr=y;} void display() const { cout <<mo<<'/'<<da<<'/'<<yr<<endl; } }; Date::Date() { cout <<Date constructor running<<endl; mo=0; da=0; yr=0; } int main() { Date dates[2]; Date today(12,31,2003); dates[0]=today; dates[0].display(); dates[1].display(); return 0; } 运行程序,输出为: Date constructor running Date constructor running 12/31/2003 0/0/0 从输出中可以看出,Date()这个默认构造函数被调用了两次。 2.类对象数组和析构函数 当类对象离开作用域时,编译器会为每个对象数组元素调用析构函数。 #include iostream.h class Date { int mo,da,yr; public: Date(int m=0,int d=0,int y=0) { mo=m; da=d; yr=y;} ~Date() {cout<<Date destructor running<<endl;} void display() const {cout<<mo<<'/'<<da<<'/'<<yr<<endl; } }; int main() { Date dates[2]; Date today(12,31,2003); dates[0]=today; dates[0].display(); dates[1].display(); return 0; } 运行程序,输出为: 12/31/2003 0/0/0 Date destructor running Date destructor running Date destructor running 表明析构函数被调用了三次,也就是dates[0],dates[1],today这三个对象离开作用域时调用的。 二、静态成员 可以把类的成员声明为静态的。静态成员只能存在唯一的实例。所有的成员函数都可以访问这个静态成员。即使没有声明类的任何实例,静态成员也已经是存在的。不过类当中声明静态成员时并不能自动定义这个变量,必须在类定义之外来定义该成员。 1.静态数据成员 静态数据成员相当于一个全局变量,类的所有实例都可以使用它。成员函数能访问并且修改这个值。如果这个静态成员是公有的,那么类的作用域之内的所有代码(不论是在类的内部还是外部)都可以访问这个成员。下面的程序通过静态数据成员来记录链表首项和末项的地址。 #include iostream.h #include string.h class ListEntry { public: static ListEntry* firstentry; private: static ListEntry* lastentry; char* listvalue; ListEntry* nextentry; public: ListEntry(char*); ~ListEntry() { delete [] listvalue;} ListEntry* NextEntry() const { return nextentry; }; void display() const { cout<<listvalue<nextentry=this; lastentry=this; listvalue=new char[strlen(s)+1]; strcpy(listvalue,s); nextentry=0; } int main() { while (1) { cout<>name
说明:本书稿为张孝祥、袁龙友两位老师在2000 年依据张孝祥的vc 讲课记录整理,由于时间关系,仅仅是写成了草稿,欢迎大家使用! 第1 章 掌握C 1.1 类的定义与应用 1.1.1 结构的定义 1.1.2 类的定义 1.1.2.1 类与结构 1.1.2.2 类的使用 (例子代码EX01-00) 1.2 函数的重载 1.2.1 重载参数个数不同的函数 (例子代码EX01-01) 1.2.2 重载参数数据类型不同的函数 (例子代码EX01-02) 1.3 构造函数析构函数 1.3.1 构造函数 1.3.2 析构函数 (图1,没有)(图2,没有) 1.4 this 指针的引用 1.5 类的继承与protected 访问修饰符 1.5.1 单一继承 (例子代码EX01-03) (图x,没有) 1.5.2 多重继承 1.6 虚函数与多态性 1.7 类的书写规范 1.8 小结 第2 章 Windows 程序内部运行原理 2.1 Windows 应用程序,操作系统,计算机硬件之间的相互关系 2.1.1 关于API (图1,没有) 2.1.2 关于消息及消息队列 (图1、图2 没有) 2.2 什么是句柄 2.3 谈谈WinMain 函数 (例子代码EX02-00) 2.3.1 WinMain 函数的定义及功能 2.3.2 窗口及其生成 2.3.2.1 如何设计一个窗口类——步骤1 2.3.2.2 注册设计好的窗口类——步骤2 2.3.2.3 创建窗口——步骤3 2.3.2.4 显示创建的窗口——步骤4 2.3.3 消息循环 2.3.4 完成回调函数 2.4 程序编写操作步骤与实验 2.5 小结 第3 章 VC 集成开发环境介绍 3.1 Visual C 开发环境 3.1.1 工作区窗格 3.1.2 输出窗格 3.1.3 编辑区 3.1.4 菜单栏、工具栏、状态栏 3.2 系统菜单功能介绍 3.2.1 File 菜单 3.2.2 Edit 菜单 3.2.3 View 菜单 3.2.4 Insert 菜单 3.2.5 Project 菜单 3.2.6 Build 菜单 3.2.6 Tools 菜单 3.2.7 Window 菜单 3.2.8 Help 菜单 3.3 Visual C 重要工具介绍 3.3.1 C/C 编译器 3.3.2 资源编辑器 3.3.3 资源编译器 3.3.4 链接器和调试器 3.3.5 AppWizard 和ClassWizard 3.3.6 资源浏览器 3.3.7 Microsoft 活动模板库、仓库 3.4 小结 第4 章 MFC 应用程序框架剖析 4.1 什么是MFC 以及MFC 的特点 (例子代码EX04-00) 4.2 MFC 应用程序框架 (例子代码EX04-01) 4.3 应用程序框架说明 4.4 文档-视图体系结构 4.4.1 文档-视图相互作用的函数 4.4.2 单文档-视图应用程序结构 4.4.2 多文档-视图应用程序结构 4.5 MFC 消息映射机制 4.5.1 消息的种类 4.5.2 应用程序的Run 函数 4.5.3 消息映射表 4.5.4 如何添加消息映射 4.6 ClssWizard 的使用 4.6.1 ClssWizard 概貌 4.6.2 如何添加消息处理函数 4.6.3 如何添加成员变量 4.6.4 如何添加一个新类 第5 章 图形与文本 5.1 理解图形设备接口 5.2 设备描述表 5.2.1 什么是设备描述表 5.2.2 MFC 中的设备描述表类 5.2.3 获取设备描述表 5.3 Windows 的GDI 对象 5.4 GDI 对象的创建 5.4.1 自定义画刷(CBrush) 5.4.2 自定义画笔(CPen) 5.4.3 自定义字体(CFont) 5.5 GDI 对象的使用及示例 5.5.1 画笔的使用 5.5.1.1 在MFC 程序中画线 5.5.1.2 在Windows Application 程序中画线 5.5.1.3 实现橡皮筋功能 5.5.2 画刷的使用 5.5.2.1 带颜色的画刷的使用 5.5.2.2 带位图的画刷的使用 5.5.3 字体的使用 5.5.3.1 一个简单的文字处理程序 5.5.3.2 模拟卡拉OK 程序 5.5.3.3 剪切区和路径层 第六章 菜单、工具栏和状态栏 6.1 菜单 6.1.1 菜单介绍 6.1.2 创建一个菜单 6.1.2.1 添加一个菜单资源 6.1.2.2 利用菜单编辑器编辑菜单资源 6.1.2.3 将菜单加入到应用程序中 6.1.2.4 给菜单项添加COMMAND 消息处理 6.1.2.5 给菜单项添加UPDATE_COMMAND_UI 消息处理 6.1.2.6 一个简单的绘图程序 6.1.3 在应用程序中控制菜单 6.1.3.1 在应用程序中取得菜单 6.1.3.2 在应用程序中修改菜单的状态 6.1.3.3 在应用程序中添加、删除、插入菜单或菜单项 6.1.3.4 一个简易的电话本程序 6.1.4 创建快捷方式菜单 6.2 工具栏 6.2.1 工具栏介绍 6.2.1.1 熟悉CToolBar 类 6.2.1.2 AppWizard 是如何创建工具栏 6.2.1.3 利用工具栏编辑器设计工具栏按钮 6.2.2 新建一个工具栏 6.2.3 显示/隐藏工具栏 6.3 状态栏 6.3.1 状态栏介绍 6.3.1.1 熟悉CStatusBar 类 6.3.1.2 AppWizard 是如何创建状态栏 6.3.2 修改状态栏 6.3.2.1 指示器数组 6.3.2.2 修改状态栏窗格 6.3.3 在状态栏上显示鼠标坐标、时钟和进度条 6.3.3.1 在状态栏上显示鼠标坐标 6.3.3.2 在状态栏上显示时钟 6.3.3.3 在状态栏上显示进度条 第七章 对话框和控件 7.1 对话框及控件的介绍 7.1.1 常用控件介绍 7.1.2 对话框介绍 7.1.2.1 对话框的组成 7.1.2.2 对话框的种类 7.1.2.3 使用对话框编辑器设计对话框 7.1.3 创建一个对话框 7.1.3.2 创建非模态对话框 7.1.3.3 对话框的数据交换机制 7.1.3.4 创建模态对话框 7.1.4 模态对话框和非模态对话框的区别 7.1.5 按钮逃跑小程序 7.2 属性页和向导对话框 7.2.1 创建属性页对话框 7.2.1 创建向导对话框 7.3 公用对话框 7.3.1 增加设置对话框来完善绘图程序 7.3.2 颜色对话框的使用 7.3.3 字体对话框的使用 7.3.4 控制控件颜色做漂亮界面 第8 章 文档序列化 8.1 序列化 8.1.1 CArchive 类和Serialize 函数 8.1.2 使自己的类支持序列化 8.1.3 实例:保存和显示图形 8.2 CFile 类 8.2.1 CFile 类的构造函数 8.2.2 打开文件 8.2.3 读写数据 8.2.4 关闭文件 8.3 文件I/O 处理 8.3.1 利用MFC 类来实现 8.3.2 利用C 函数来实现 8.3.3 利用C 函数来实现 8.3.4 利用API 函数来实现 8.3.5 创建保存、打开对话框 8.4 注册表操作 8.4.1 什么是注册表 8.4.2 注册表结构 8.4.3 修改注册表 第9 章 修改框架程序的显示效果 9.1 修改Windows 应用程序外观样式 9.1.1 在框架类中修改程序外观 9.1.2 在视图类中修改程序外观 9.2 制作动画图标 9.3 将图片作为窗口显示的背景 第10 章 网络编程 10.1 计算机网络的基本概念 10.1.1 计算机网络的分类 10.1.2 网络拓扑结构 10.2 网络体系结构和网络协议 10.2.1 ISO/OSI 参考模型 10.2.2 TCP/IP 参考模型 10.2.3 TCP/IP 协议 10.2.3.1 协议概述 10.2.3.2 TCP/IP 协议层次结构及各种协议介绍 10.2.3.3 IP 地址 10.2.3.4 端口号 10.2.4 专业术语解释 10.3 Socket 套接字 10.3.1 Socket 介绍 10.3.2 关于协议族和地址族 10.3.3 使用Socket 10.3.3.1 创建Socket 10.3.3.2 指定本地地址及端口号 10.3.3.3 建立连接 10.3.3.4 监听连接 10.3.3.5 发送数据 10.3.3.6 接收数据 10.3.3.7 关闭套接字 10.3.4 套接字一般调用过程 10.4 WinSock 编程机制 10.4.1 认识Windows Socket 10.4.2 Windows Sockets 库函数介绍 10.4.2.1 Berkeley socket 函数 10.4.2.2 数据库函数 10.4.2.3 Windows 专有扩展函数 10.5 WinSock 编程实例 10.5.1 实例一:面向连接服务的socket 调用 10.5.2 实例二:面向非连接服务的socket 调用 10.5.3 实例三:基于字符界面的聊天程序 第11 章 线程间的同步 11.1 进程和线程的概念 11.2 Win32 的线程 11.2.1 线程的创建 11.2.2 线程的终止 11.2.3 实例:通过创建多线程来编写网络聊天程序 11.3 MFC 的线程处理 11.3.1 创建工作者线程 11.3.2 创建用户界面线程 11.4 线程同步 11.4.1 为什么要同步 11.4.2 等待函数 11.4.3 同步对象 11.4.3.1 关键代码段 11.4.3.2 互斥对象 11.4.3.3 信标对象 11.4.3.4 事件对象 11.4.4 如何选择同步对象 第12 章 进程间的通讯 12.1 进程控制 12.1.1 进程的创建 12.1.2 进程的终止 12.2 进程间通讯 12.2.1 剪贴板通讯方式 12.2.2 邮槽通讯方式 12.2.3 管道通讯方式 12.2.3.1 命名管道通讯 12.2.3.2 匿名管道通讯 第14 章 ActiveX 技术 14.1 ActiveX 简介 14.2 ActiveX 控件和普通Windows 控件 14.2.1 ActiveX 控件和普通Windows 控件的相同点 14.2.2 ActiveX 控件和普通Windows 控件的相同点 14.3 ActiveX 控件的属性、方法和事件 14.3.1 ActiveX 控件的属性 14.3.2 ActiveX 控件的方法 14.3.3 ActiveX 控件的事件 14.4 创建ActiveX 控件
本教程共分为5个部分,第一部分是C语言提高部分,第二部分为C++基础部分,第三部分为C++进阶部分,第四部分为C、C++及数据结构基础部分,第五部分为C_C++与设计模式基础,内容非常详细. 第一部分 C语言提高部分目录 01_初学者的企业用人标准寻找引言 02_socketclient_api模型的抽象_初学者应知的标准_传智扫地僧 03_本套视频总体课程简介 04_就业班课程总体简介_课堂答疑 05_初学者建立信心 06_学员学习标准_排序及问题抛出 07_数组做函数参数退化问题剖析_传智扫地僧 08_数据类型基础提高 09_数据类型引申和思考 10_变量本质剖析和内存四区模型引出_传智扫地僧 11_c的学习重理解到位_对初学者_传智扫地僧 12_直接通过内存标号操作内存空间_课堂答疑 13_中午课程回顾 14_内存四区基本原理_全局区案例理解 15_内存四区_堆栈案例理解 16_课堂答疑_理解指针的关键关键在内存 17_vs20102013上配置#系列快捷方式 18_栈的属性和buf地址增长方向是两个不同的概念 19_函数调用模型_主调函数和被调用函数 20_课堂答疑_函数调用流程入栈出栈过程 21_指针也是一种数据类型_基础 22_指针也是一种数据类型_强化_传智扫地僧 源码及文档 01_课程回顾 02_作业题强化和野指针 03_向null地址copy数据和不断改变指针指向强化 04_有关字面量 05_间接赋值从0级指针到1级指针 06_间接赋值从1级指针到2级指针_技术推演_传智扫地僧 07_间接赋值是指针存在的最大意义 08_间接赋值成立的三个条件和应用场景 09_指针学习思路应用清晰起来 10_指针强化3和指针强化4思想讲解 11_字符串的基本操作 12_数组中括号与指针关系和数组名常量指针分析 13_字符串一级指针内存模型_传智扫地僧 14_字符串copy函数技术推演 15_字符串copy函数强化训练_判断null_引入辅助指针变量_传智扫地僧 16_项目开发模型强化_strstr_while模型_重要 17_作业考试强化 源码及文档 01_上一次课程回顾 02_两头堵模型 03_字符串反转_方法1指针 04_字符串反转_方法2递归逆序(3个点)_传智扫地僧 05_考试题解答和项目开发代码书写手法 06_一级指针易错模型分析_重点 07_C语言中的const知识点总结 08_指针的输入和输出模型 09_课堂答疑_指针所指向内存释放 10_二级指针做输入_第1种内存模型 11_二级指针做输入_第2种内存模型 12_二级指针做输入_第2种内存模型_课堂答疑_多维数组名本质抛砖 13_二级指针做输入_第3种内存模型_传智扫地僧 14_二级指针三种内存模型示意图_传智扫地僧 15_玩转多级指针_传智扫地僧 16_两个辅助指针变量挖字符串测试框架搭建 18_作业 源码及文档 01_课程回顾 02_两个赋值指针变量挖字符训练_第3种内存模型_传智扫地僧 03_多级指针的野指针问题(释放问题)_传智扫地僧 04_学员作业点评_典型错误吸取教训 05_数组类型 06_数组指针类型和定义数组指针变量的3种方法 07_多维数组名本质剖析_传智扫地僧 08_多维数组的【】和多级指针星号转化推演 09_多维数组做函数参数技术推演和退化原因抛出 10_多维数组做函数参数退化总结_ 11_指针数组的应用场景01 12_指针数组自我结束能力(三种表示方法) 13_干活要知道在什么框架之下干活 14_结构体类型和变量定义及基本操作 15_结构体元素做函数参数pk结构指针做函数参数 16_结构体做函数基本操作 17_结构体做函数内存分配指针 18_结构中套一级指针 19_结构体中套二级指针_传智扫地僧 20_作业强化 21_C提高课程_day01-day04_知识体系梳理_传智扫地僧 源码及文档 01_上次课程回顾 02_二级指针三种内存模型综合训练_框架搭建 03_二级指针三种内存模型综合训练_实现 04_二级指针三种内存模型综合训练_典型错误 05_结构体作业点评 06_结构体中的深copy和浅copy 07_结构中的高级话题_偏移量 08_结构中的高级话题_偏移量强化 09_文件操作api基本概念 10_按照字符读写文件 11_按照行方式操作文件 12_按照块的方式操作文件 13_中午课程回顾 14_配置文件读写案例功能介绍 15_配置文件读写案例_接口设计 16_配置文件读写案例_集成框架搭建 17_配置文件读写案例_读配置项实现 18_配置文件读写案例_写和修改接口实现 19_文件加密案例_思路分析 20_文件加密案例_文件搬运实现 21_文件加密案例_文件加密功能集成 22_文件加密案例_文件加密实现 23_作业 24_学员二级指针代码bug调试_传智扫地僧 源码及文档 01_课程回顾 02_解密作业 03_指针用法杂项 04_再谈多级指针做输出_传智扫地僧 05_动态库的基本概念和使用 06_动态库测试环境和调试环境搭建 07_socketclient动态库函数_初始化实现wmv 08_socketclient动态库函数_发送接受释放实现wmv 09_socketclient动态库_第二套api函数_传智扫地僧 10_socketclient动态库_日志功能集成 11_项目中检索内存泄漏使用和基本原理 12_动态库基本知识和环境调试注意 13_动态库内存释放问题 源码及文档 01_上一次课程回顾 02_链表热身_结构体中套元素和指针 03_结构体数据类型的嵌套定义和函数的嵌套调用是两个不同的概念 04_静态链表及局限性 05_链表的分类和链表的辅助指针变量 06_链表api函数搭建 07_链表的创建和打印 08_链表的插入操作和辅助指针变量分析_传智扫地僧 09_链表的删除和销毁 10_链表的逆置_传智扫地僧 11_链表的逆置_课堂答疑 12_课堂答疑pheadnextnext 13_中午课程回顾 14_传统链表和非传统链表 15_链表的技术体系推演 16_通用链表库集成和测试 17_C提高课程_day05-day07_知识体系梳理_传智扫地僧 源码及文档 第二部分 C++基础目录 01_C++基础课程的安排和需要持之以恒的学习态度 02_简单的C++程序helloworld 03_用面向过程和面向对象方法求解圆形面积_类和对象的关系思考_传智扫地僧 04_类中不写成员函数易犯错误模型 05-易犯错误模型-为什么需要成员函数(补充资料)-传智扫地僧 06_课堂答疑类中写成员函数_调用的时才会执行 07_程序设计方法发展历程 08_C语言和C++语言的关系_工作经验分享 09_namespace和iotream 10_实用性加强_register增强_检测增强 11_struct关键字类型增强 12_c++类型类型检查加强 13_新增数据类型bool类型 14_中午课程回顾 15_c++中的三目运算符_传智扫地僧 16_const的基础和const符号表机制探究_传智扫地僧 17_const和#define的对比_传智扫地僧 18_引用的基础知识(定义和函数参数) 19_复杂数据类型引用做函数参数__传智扫地僧 20_引用的本质剖析_传智扫地僧 21_函数返回值是引用(当左值右值)_传智扫地僧 源码及文档 01_上一次课程复习 02_指针的引用_传智扫地僧 03_常引用 04_inline内联函数 05_函数参数相关扩展 06_函数重载 07_函数重载和函数指针在一起 08_中午课程回顾 09_c++学习路线和c++基础课程学习标准_传智扫地僧 10_类的封装和访问控制 11_struct和class关键字区别 12_类的声明和类的实现分开 13_面向过程向面向对象转变案例1 14_面向过程向面向对象转变案例2 15_面向过程向面向对象转变案例3 16_作业 17_C++基础课程day01-day02_知识体系梳理_传智扫地僧 源码及文档 01_上一次课程回顾 02_构造和析构的基础知识 03_构造和析构的用途演示 04_构造函数的调用(无参数和有参构造)_传智扫地僧 05_课堂答疑对象的初始化和对象的赋值是两个不同的概念 06_为什么需要构造和析构函数 07_copy构造函数的调用时机1和2 08_课堂答疑 09_copy构造函数调用时机3_传智扫地僧 10_copy构造函数调用时机4_函数返回值是匿名对象_传智扫地僧 11_copy构造函数调用时机4_函数返回值是匿名对象的去和留的剖析_传智扫地僧 12_构造和析构的重点整理 13_构造和析构总结 14_中午课程复习 15_构造函数的调用规则研究 16_浅拷贝问题抛出 17_浅拷贝问题分析_传智扫地僧 18_浅拷贝问题解决_深拷贝_显示编写拷贝构造函数 19_深拷贝和浅拷贝_默认的等号操作符也是浅拷贝_传智扫地僧 20_构造函数的初始化列表 21_强化训练1_构造和析构调用顺序 22_强化训练2_匿名对象生命周期 23_强化训练3_构造中调用构造(产生匿名对象)_传智扫地僧 24_new和delete的基本语法 25_new和delete的深入分析 26_静态成员变量和静态成员函数 27_C++面向对象模型初探_传智扫地僧 28_this指针 29_作业 源码及文档 01_上一次课程回顾 02_const修饰的是谁_传智扫地僧 03_this的const修饰课堂答疑 04_全局函数pk成员函数(返回元素,引用,星号this) 05_强化训练数组类_类的设计和测试程序 06_强化训练数组类_类的实现和测试 07_友元函数 08_友元类 09_运算符重载入门基础推演_传智扫地僧 10_运算符重载语法理论知识介绍 11_中午课程回顾 12_成员函数和友元函数完成二元运算符重载 13_成员函数和友元函数完成一元运算符重载(前置) 14_成员函数和友元函数完成一元运算符重载(后置) 15_友元函数实现左移右移操作符重载(函数返回值当左值需返回引用)_传智扫地僧 16_友元函数实现操作符重载知识总结 17_重载等号操作符_传智扫地僧 18_数组类小案例_操作符重载需求 19_数组类小案例_重载[]_传智扫地僧 20_数组类小案例_重载等号_传智扫地僧 21_数组类小案例_重载==和!= 22_作业 源码及文档 01_上一次课程的回顾 02_()运算符重载 03_逻辑与和逻辑或运算符重载说明 04_课堂答疑_逻辑与和逻辑或运算符重载 05_MyString类案例_构造和析构函数 06_MyString类案例_重载等号和数组操作符_传智扫地僧 07_MyString类案例_重载左移操作符 08_MyString类案例_重载双等号和不等号 操作符 09_MyString类案例_重载大于和小于操作符 10_MyString类案例_其他技巧 11_MyString类案例_重载右移操作符 12_C++基础课程day03-day05_知识体系梳理 13_作业和考试 源码及文档 01_继承的概念 02_子类可以访问父类的属性和方法 03_派生类的访问控制 04_派生类的访问控制综合训练_传智扫地僧 05_类型兼容性原则_传智扫地僧 06_继承中的构造和析构 07_继承和组合混搭下的构造和析构_传智扫地僧 08_继承中的同名成员变量和同名成员函数 09_继承的static关键字 10_多继承的基本语法 11_二义性和虚继承解决方案 12_中午课程回顾 13_多继承原理抛砖_传智扫地僧 14_多态思想引言 15_类型兼容性原则遇上还是函数重写_面向对象新需求_传智扫地僧 16_多态案例_多态的意义_多态成立的三个条件_传智扫地僧 17_多态案例丰富多彩和多态的理论知识 18_虚析构函数 19_重载重写重定义_问题抛出 20_重载重写重定义_概念分析_传智扫地僧 21_重载重写重定义_课堂答疑_传智扫地僧 文档和源码 01_上一次课程回顾 02_多态原理探究_传智扫地僧 03_证明vptr指针的存在 04_子类的vptr指针是分步初始化的_传智扫地僧 05_面试题强化_多态相关 06_父类指针的步长和子类指针的步长不一样 07_课堂答疑什么时候子类的步长和父类的步长一样 08_抽象类基本语法 09_抽象类在多继承中的应用 10_面向抽象类编程_计算程序员工资 11_中午课程回顾 12_信息系统框架集成第三方产品案例_背景和需求 13_信息系统框架集成第三方产品案例_编码实现分析_传智扫地僧 14_信息系统框架集成第三方产品案例_socket抽象类和框架搭建__传智扫地僧 15_信息系统框架集成第三方产品案例_框架实现第一个socket类厂商实现 16_信息系统框架集成第三方产品案例_第二个socket类厂商实现 17_信息系统框架集成第三方产品案例_加解密抽象类和加解密厂商类实现 18_信息系统框架集成第三方产品案例_集成测试加密厂商和socket厂商入围 19_信息系统框架集成第三方产品案例_集成框架变成类方式_传智扫地僧 20_信息系统框架集成第三方产品案例_几个重要的面向对象思想_传智扫地僧 21_作业 文档和源码 01_上一次课程回顾 02_数组指针语法梳理 03_函数指针语法梳理_传智扫地僧 04_函数指针做函数参数思想剖析_传智扫地僧 05_函数指针的正向调用案例 06_C动态库升级成框架案例_项目需求和基本思想_传智扫地僧 07_C动态库升级成框架案例_开发环境搭建 08_C动态库升级成框架案例_方法1动态库中直接添加回调函数_传智扫地僧 09_C动态库升级成框架案例_方法2把回调函数缓存到动态库_编写 10_C动态库升级成框架案例_方法2把回调函数混存到动态库_测试 11_C++基础课程day06-day08_知识体系梳理 文档和源码 第三部分 C++进阶部分目录 01_上一次课程知识点_梳理 02_函数模板为什么和函数模板语法基础 03_课堂答疑_遇到莫名其妙的问题_重新编译 04_函数模板当函数参数 05_普通函数和模板函数区别_传智扫地僧 06_函数模板和函数重载在一起(调用规则研究)_传智扫地僧 07_函数模板机制探究上 08_函数模板机制探究下_传智扫地僧 09_课堂答疑_二次编译 10_类模板语法_数据类型和算法的分离_抛砖 11_单个类模板基本语法 12_类模板_派生_普通类语法 13_类模板_派生_类模板语法 14_中午知识点梳理 15_复数类_所有函数都写在类的内部 16_复数类_所有函数都写在类的外部_上 17_复数类_所有函数都写在类的外部_下 18_复数类_所有函数都写在类的外部(h和cpp分开) 19_类模板中的static关键字 20_案例_数组模板类_需求和类的初步设计 21_案例_数组模板类_测试框架搭建 22_案例_数组模板类_类的实现和测试_传智扫地僧 23_案例_数组模板类_数组元素存储的是类对象思想抛砖_传智扫地僧 24_作业 代码 文档 01_泛型编程_知识点梳理 02_模板数组类_作业讲解和思想强化(数据类型和算法的分离)_传智扫地僧 03_类型转换_static_cast和reinterpret_cast 04_类型转换_dynamic_cast和reinterpret_cast_传智扫地僧 05_类型转换_const_cast 06_异常的基本语法 07_异常机制基本思想梳理 08_栈解旋unwinding 09_异常接口声明 10_异常类型_异常变量的生命周期上 11_异常类型_异常变量的生命周期下_传智扫地僧 12_中午知识点梳理 13_异常的层次结构_传智扫地僧 14_标准异常库 15_流类库结构 16_标准IO_输入api_上 17_标准IO_输入api_下 18_标准IO输出_api和格式控制 19_文件的读写 代码 文档 01_stl总体课程安排 02_stl容器算法迭代器三大概念入门 03_stl理论知识_基本概念串讲 04_stl的string的典型操作1_初始化_遍历_连接_和字符指针转化_查找替换传智扫地僧 05_stl的string的典型操作2_删除和插入 06_stl的string的常用算法 07_vector基本操作_对象创建_头部尾部操作元素_数组方式遍历vector 08_vector的迭代器遍历和迭代器的种类_传智扫地僧 09_vector基本操作_删除和插入_传智扫地僧 10_中午知识点回顾 11_deque容器基本操作 12_stack栈模型 13_queue模型 14_list容器模型基本操作 15_优先级队列priority_queue基本操作 16_set容器_插入_遍历_基本数据类型比较 17_set容器_自定义数据类型排序(仿函数应用)_insert判断返回值(pair的使用)_传智扫地僧_ 18_set容器_find查找_equal_range(pair的使用)_传智扫地僧_ 19_multiset容器基本操作_ 文档 源码 01_上一次课程知识点回顾 02_map容器基本操作_插入和插入结果判断_传智扫地僧 03_map容器基本操作_查找和查找的异常处理 04_multimap容器案例_按照部门_增删改查员工信息 05_容器的值拷贝语意 06_各个容器特点比较 07_stl算法设计理念_函数对象和函数对象当参数和返回值_传智扫地僧 08_stl算法设计理念_一元函数对象和一元谓词 09_中午课程知识点回顾 10_stl算法设计理念_二元函数对象和二元谓词 11_stl算法设计理念_二元谓词在set集合的应用 12_stl算法设计理念_预定义函数对象和函数适配器1_传智扫地僧 13_stl算法设计理念_预定义函数对象和函数适配器2_案例_传智扫地僧 14_stl容器算法迭代器的设计理念_重要理论思想总结_传智扫地僧 15_stl的算法概念和分类 16_stl算法_foreach和transform基本使用 17_stl算法_foreach和transform算法比较_transform算法源码追踪_传智扫地僧 文档 源码 01_上一次课程复习 02_stl常用算法_查找相关 03_stl常用算法_排序相关 04_stl常用算法_拷贝和替换相关 05_stl常用算法_算法和生成 06_stl常用算法_集合运算 07_STL案例_演讲比赛_比赛介绍和需求分析 08_STL案例_演讲比赛_搭建案例框架_传智扫地僧 09_STL案例_演讲比赛_实现思路分析_传智扫地僧 10_STL案例_演讲比赛_业务函数实现_产生选手和选手抽签 11_STL案例_演讲比赛_业务函数实现_选手比赛_传智扫地僧 12_STL案例_演讲比赛_业务函数实现_比赛晋级结果打印 13_STL课程_知识体系梳理_传智扫地僧 文档 源码 第四部分 01_数据结构课程_学习思路_学习基础 02_数据结构概念_基本概念 03_数据结构概念_逻辑关系_物理结构 04_算法基本概念和大O表示 05_算法的时间复杂度 06_算法的空间复杂度_空间换时间案例 07_课堂答疑_学员思路 08_线性表的理论知识梳理_重点在链表算法和具体数据类型的分离 09_线性表顺序存储设计和实现_环境搭建 10_线性表顺序存储设计和实现_api函数实现1 11_线性表顺序存储设计和实现_api函数实现2_插入算法 12_线性表顺序存储设计和实现_api函数实现3_get和delete 13_线性表顺序存储设计和实现_总结 14_线性表链式存储_设计与实现_框架搭建和链表技术领域推演_传智扫地僧 15_线性表链式存储_设计与实现_api实现_传智扫地僧 16_线性表链式存储_设计与实现_api实现下_传智扫地僧 17_线性表链式存储_总结 18_c++模板链表_类设计和测试框架搭建 19_c++模板链表_类实现 代码 文档 01_数据结构day01_知识点梳理 02_c++链表模板类_思想加强 03_循环链表api熟悉 04_循环链表应用_约瑟夫问题求解 05_循环链表_插入算法分析_传智扫地僧 06_循环链表_删除算法分析 07_循环链表_游标课堂答疑 08_循环链表_api串讲 09_循环链表_api熟悉 10_栈的顺序存储_设计与实现_测试框架搭建 11_中午课程回顾 12_栈模型和链表模型_顺序存储_思想分析_传智扫地僧 13_栈的顺序存储_设计与实现_api实现和调试 14_栈的顺序存储_设计与实现_课堂答疑 15_栈链式存储_设计与实现_测试框架搭建 16_栈链式存储_设计与实现_栈结点转换成链表结点_思想分析_传智扫地僧 17_栈链式存储_设计与实现_api实现_传智扫地僧 18_栈链式存储_设计与实现_内存管理 19_栈的应用案例_就近匹配 20_栈的应用案例_中缀转后缀 21_栈的应用案例_基于后缀表达式的计算_传智扫地僧 22_栈的应用案例_程序讲解 23_树模型抛砖 代码 文档 01_上一次课程_知识点回顾 02_队列顺序存储_设计与实现_测试框架 03_队列顺序存储_设计与实现_api函数的实现 04_队列链式存储_设计与实现_测试框架 05_队列链式存储_设计与实现_api函数实现 06_树的概念_定义_表示法_二叉树转换_树的存储 07_二叉树的概念_定义和性质 08_二叉树的概念_表示法_二叉树遍历 09_中午课程回顾 10_二叉树编程_遍历本质剖析和递归方式遍历_传智扫地僧 11_二叉树编程案例1_求叶子结点的数目 12_二叉树编程案例2和3_求树高度_拷贝二叉树 13_二叉树编程案例_课堂答疑 14_树非递归中序遍历_思想分析 15_树非递归中序遍历_遍历过程演示 16_树非递归中序遍历_实现(stl方式)_传智扫地僧 17_stl栈模型组合容器类对象_思想抛砖 18_创建树思想抛砖 代码 文档 01_上一次课程回顾 02_创建树_先序和中序确定树 03_学习数据结构_常用工具介绍 04_创建树_#号法 05_创建树_#号法编程实践 06_创建树_#号法课堂答疑 07_线索化_概念_过程分析 08_线索化_两个赋值指针变量线索化思想 09_线索化_线索化初始化流程 10_线索化_遍历思想 11_线索化_遍历树时,把结点插入链表中 12_中午课程总结和线索化逆序访问 13_霍夫曼树概念 14_排序_概念 15_排序_选择法 16_排序_插入法 17_排序_冒泡 18_排序_希尔排序 19_排序_希尔排序_分组很重要 20_排序_快速排序 21_排序_归并 22_数据结构课程_知识体系梳理 代码 文档 01_上一次课程知识点回顾 02_递归需要需要掌握的点补充 03_链表类_链式存储_测试 04_链表类_链式存储_api实现 05_链表类_链式存储_课堂答疑 06_栈类_链式存储_api实现 07_队列类_链式存储设计与实现_api 08_链表类_顺序存储_类设计和测试框架 09_链表类_顺序存储_类api实现 10_栈类_顺序存储_实现 11_队列类_顺序存储设计与实现 c++基础串讲复习1 c++基础串讲复习2 c++基础串讲复习3 c++基础串讲复习4 c++基础串讲复习5 代码 数据结构书籍和工具收集 文档 第四部分 C和C++与数据结构基础 01_数据结构课程_学习思路_学习基础 02_数据结构概念_基本概念 03_数据结构概念_逻辑关系_物理结构 04_算法基本概念和大O表示 05_算法的时间复杂度 06_算法的空间复杂度_空间换时间案例 07_课堂答疑_学员思路 08_线性表的理论知识梳理_重点在链表算法和具体数据类型的分离 09_线性表顺序存储设计和实现_环境搭建 10_线性表顺序存储设计和实现_api函数实现1 11_线性表顺序存储设计和实现_api函数实现2_插入算法 12_线性表顺序存储设计和实现_api函数实现3_get和delete 13_线性表顺序存储设计和实现_总结 14_线性表链式存储_设计与实现_框架搭建和链表技术领域推演_传智扫地僧 15_线性表链式存储_设计与实现_api实现_传智扫地僧 16_线性表链式存储_设计与实现_api实现下_传智扫地僧 17_线性表链式存储_总结 18_c++模板链表_类设计和测试框架搭建 19_c++模板链表_类实现 代码 文档 01_数据结构day01_知识点梳理 02_c++链表模板类_思想加强 03_循环链表api熟悉 04_循环链表应用_约瑟夫问题求解 05_循环链表_插入算法分析_传智扫地僧 06_循环链表_删除算法分析 07_循环链表_游标课堂答疑 08_循环链表_api串讲 09_循环链表_api熟悉 10_栈的顺序存储_设计与实现_测试框架搭建 11_中午课程回顾 12_栈模型和链表模型_顺序存储_思想分析_传智扫地僧 13_栈的顺序存储_设计与实现_api实现和调试 14_栈的顺序存储_设计与实现_课堂答疑 15_栈链式存储_设计与实现_测试框架搭建 16_栈链式存储_设计与实现_栈结点转换成链表结点_思想分析_传智扫地僧 17_栈链式存储_设计与实现_api实现_传智扫地僧 18_栈链式存储_设计与实现_内存管理 19_栈的应用案例_就近匹配 20_栈的应用案例_中缀转后缀 21_栈的应用案例_基于后缀表达式的计算_传智扫地僧 22_栈的应用案例_程序讲解 23_树模型抛砖 代码 文档 01_上一次课程_知识点回顾 02_队列顺序存储_设计与实现_测试框架 03_队列顺序存储_设计与实现_api函数的实现 04_队列链式存储_设计与实现_测试框架 05_队列链式存储_设计与实现_api函数实现 06_树的概念_定义_表示法_二叉树转换_树的存储 07_二叉树的概念_定义和性质 08_二叉树的概念_表示法_二叉树遍历 09_中午课程回顾 10_二叉树编程_遍历本质剖析和递归方式遍历_传智扫地僧 11_二叉树编程案例1_求叶子结点的数目 12_二叉树编程案例2和3_求树高度_拷贝二叉树 13_二叉树编程案例_课堂答疑 14_树非递归中序遍历_思想分析 15_树非递归中序遍历_遍历过程演示 16_树非递归中序遍历_实现(stl方式)_传智扫地僧 17_stl栈模型组合容器类对象_思想抛砖 18_创建树思想抛砖 代码 文档 01_上一次课程回顾 02_创建树_先序和中序确定树 03_学习数据结构_常用工具介绍 04_创建树_#号法 05_创建树_#号法编程实践 06_创建树_#号法课堂答疑 07_线索化_概念_过程分析 08_线索化_两个赋值指针变量线索化思想 09_线索化_线索化初始化流程 10_线索化_遍历思想 11_线索化_遍历树时,把结点插入链表中 12_中午课程总结和线索化逆序访问 13_霍夫曼树概念 14_排序_概念 15_排序_选择法 16_排序_插入法 17_排序_冒泡 18_排序_希尔排序 19_排序_希尔排序_分组很重要 20_排序_快速排序 21_排序_归并 22_数据结构课程_知识体系梳理 代码 文档 01_上一次课程知识点回顾 02_递归需要需要掌握的点补充 03_链表类_链式存储_测试 04_链表类_链式存储_api实现 05_链表类_链式存储_课堂答疑 06_栈类_链式存储_api实现 07_队列类_链式存储设计与实现_api 08_链表类_顺序存储_类设计和测试框架 09_链表类_顺序存储_类api实现 10_栈类_顺序存储_实现 11_队列类_顺序存储设计与实现 c++基础串讲复习1 c++基础串讲复习2 c++基础串讲复习3 c++基础串讲复习4 c++基础串讲复习5 代码 数据结构书籍和工具收集 文档 第5部分 C_C++与设计模式基础 01_设计模式课程安排和要求 02_UML的建模和基本概念 03_UML图_用例图_基础 04_UML图_用例图_人事管理系统案例_传智扫地僧 05_UML图_类图_基础和类关系依赖 06_UML图_类图_关联_聚合_组合_传智扫地僧 07_UML图_时序图_传智扫地僧 08_UML图_活动图_传智扫地僧 09_UML图_状态图_进程状态案例 10_UML图_协作图_包图_部署图 11_设计模式_概念和设计原则 12_中午课程回顾 13_设计模式基本原则_依赖倒转 14_设计模式基本_依赖倒置和迪米特法则 15_单例模式_懒汉式和饿汉式 16_懒汉式遇上多线程问题 17_懒汉式多线程同步优化 18_简单工厂模式 19_工厂模式_传智扫地僧 文档 源码 01_上一次课程知识点梳理 02_抽象工厂模式 03_抽象工厂课堂答疑 04_建造者模式_理论模型 05_建造者模式_实现 06_建造者模式_问题抛出 07_原型模式 08_建造模式总结 09_课堂交流从建造者模式说开去 10_厚积薄发话题 11_代理模式_传智扫地僧 12_装饰模式_传智扫地僧 13_中午课程回顾 14_适配器模式 15_桥接模式_理论模型 16_桥接模式_实现_传智扫地僧 17_组合模式_上 18_组合模式_下 19_外观模式 20_享元模式 文档 源码 01_设计模式知识体系梳理01 02_模板模式_传智扫地僧 03_命令模式_技术推演上 04_命令模式_技术推演下_传智扫地僧 05_责任链模式 06_策略模式_及题外话 07_策略模式_实现 08_中介者模式_问题抛出上 09_中介者模式_实现下 10_中午知识点回顾 11_观察者模式_传智扫地僧 12_备忘录模式 13_访问者模式_概念基本原理_案例了解 14_访问者模式_实现_传智扫地僧 15_状态模式_原理及代码串讲 16_解释器模式 17_迭代器模式_思想_传智扫地僧 18_迭代器模式_实现_传智扫地僧 19_设计模式知识体系梳理02 文档 源码

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

半岛铁盒.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值