精华内容
下载资源
问答
  • 静态数据成员可以非静态成员函数访问。但静态成员函数只能访问静态数据成员。静态数据成员从属于某一个类,而不是某一个类的 对象。同理,静态成员函数也是一样。 追问 定义静态成员函数的作用有何在呢 ...
    静态数据成员可以被非静态成员函数访问。但静态成员函数只能访问静态数据成员。静态数据成员从属于某一个类,而不是某一个类的

    搜索

    对象。同理,静态成员函数也是一样。
    追问
    定义静态成员函数的作用有何在呢
    回答
    静态成员函数隶属于类,不用实例化对象,就可以直接调用静态成员函数来操作静态数据成员
    提问者评价
    太给力了,你的回答完美解决了我的问题!

    转载于:https://www.cnblogs.com/hualimengyu/p/3739588.html

    展开全文
  • 静态函数可以分为全局静态函数和类的静态成员函数。 <br />Static关键字 在类中,用static声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化,对于该类的所有对象来说,static...

    静态函数
    用static声明的函数是静态函数。静态函数可以分为全局静态函数类的静态成员函数

    Static关键字
    在类中,用static声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化对于该类的所有对象来说,static成员变量只有一份
    用static声明的方法是静态方法,在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。
    静态方法不再是针对于某个对象调用,所以不能访问非静态成员。
    可以通过对象引用或类名(不需要实例化)访问静态成员

    C++类静态数据成员与类静态成员函数
    函数调用的结果不会访问或者修改任何对象(非static)数据成员,这样的成员声明为静态成员函数比较好。且如果static int func(....)不是出现在类中,则它不是一个静态成员函数,只是一个普通的全局函数,只不过由于static的限制,它只能在文件所在的编译单位内使用,不能在其它编译单位内使用。
    静态成员函数的声明除了在类体的函数声明前加上关键字static,以及不能声明为const或者volatile之外,与非静态成员函数相同。出现在类体之外的函数定义不能制定关键字static。
    静态成员函数没有this指针

    在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据,那么我们会设立全局对象,但面向对象的程序是由对象构成的,我们如何才能在类范围内共享数据呢?

    这个问题便是本章的重点:声明为static的类成员或者成员函数便能在类的范围内共同享我们把这样的成员称做静态成员和静态成员函数。

    下面我们用几个实例来说明这个问题,类的成员需要保护,通常情况下为了不违背类的封装特性,我们是把类成员设置为protected(保护状态)的,但是我们为了简化代码,使要说明的问题更为直观,更容易理解,我们在此处都设置为public。

    以下程序我们来做一个模拟访问的例子,在程序中,每建立一个对象我们设置的类静态成员变自动加一,代码如下:

    #include <iostream>
    using namespace std;

    class Internet
    {
    public:
         Internet(char *name,char *address)
         {
             strcpy(Internet::name,name);
             strcpy(Internet::address,address);
             count++;
         }
     

         static void Internet::Sc()//静态成员函数
         {
             cout<<count<<endl;
         }

         Internet &Rq();
     

    public:
         char name[20];
         char address[20];
         static int count;//这里如果写成static int count=0;就是错误的
    };

    Internet& Internet::Rq()//返回引用的成员函数
    {
         return *this;
    }

    int Internet::count = 0;//静态成员的初始化

    void vist()
    {
         Internet a1("中国软件开发实验室","www.cndev-lab.com");
         Internet a2("中国软件开发实验室","www.cndev-lab.com");
    }
     

    void fn(Internet &s)
    {
         cout<<s.Rq().count;
    }


    void main()
    {
         cout<<Internet::count<<endl;//静态成员值的输出
         vist();
         Internet::Sc();//静态成员函数的调用
         Internet b("中国软件开发实验室","www.cndev-lab.com");
         Internet::Sc();
         fn(b);
         cin.get();
    }

    上面代码我们用了几种常用的方式建立对象,当建立新对象并调用其构造函数的时候,静态成员cout便运行加1操作,静态成员的初始化应该在主函数调用之前,并且不能在类的声明中出现,通过运行过程的观察我们发现,静态成员count的状态并不会随着一个新的对象的新建而重新定义,尽而我们了解到类的静态成员是属于类的而不是属于哪一个对象的,所以静态成员的使用应该是类名称加域区分符加成员名称的,在上面的代码中就是Internet::count,虽然我们仍然可以使用对象名加点操作符号加成员名称的方式使用,但是不推荐的,静态类成员的特性就是属于类而不专属于某一个对象。

    静态成员函数的特性类似于静态成员的使用,同样与对象无关,调用方法为类名称加域区分符加成员函数名称,在上面的代码中就是Internet::Sc();静态成员函数由于与对象无关系,所以在其中是不能对类的普通成员进行直接操作的。

    如果上面的 static void Internet::Sc()修改成为:
    static void Internet::Sc()//静态成员函数
    {
         cout<<name<<endl;//错误
         cout<<count<<endl;
    }


    静态成员函数与普通成员函数的差别就在于缺少this指针,没有这个this指针自然也就无从知道name是哪一个对象的成员了。

    根据类静态成员的特性我们可以简单归纳出几点,静态成员的使用范围:
    1.用来保存对象的个数。
    2.作为一个标记,标记一些动作是否发生,比如:文件的打开状态,打印机的使用状态,等等。
    3.存储链表的第一个或者最后一个成员的内存地址。

    为了做一些必要的练习,深入的掌握静态对象的存在的意义,我们以前面的结构体的教程为基础,用类的方式描述一个线性链表,用于存储若干学生的姓名,代码如下:

    #include <iostream>
    using namespace std;

    class Student
    {
    public:
         Student (char *name);
         ~Student();

    public:
         char name[30];
         Student *next;
         static Student *point;
    };

    Student::Student(char *name)
    {
         strcpy(Student::name,name);
         this->next=point;
         point=this;
    }

    Student::~Student ()//析构过程就是节点的脱离过程
    {
         cout<<"析构:"<<name<<endl;

         if(point==this)
         {
             point=this->next;
             cin.get();
             return;
         }

         for(Student *ps=point;ps;ps=ps->next)
         {
             if(ps->next==this)
             {
             cout<<ps->next<<""<<this->next<<endl;
             ps->next=next;//=next也可以写成this->next;
             cin.get();
             return;
             }
         }

         cin.get();
    }

    Student* Student::point=NULL;
    void main()
    {
         Student *c = new Student("marry");
         Student a("colin");
         Student b("jamesji");
         delete c;
         Student *fp=Student::point;
         while(fp!=NULL)
         {
             cout<<fp->name<<endl;
             fp=fp->next;
         }

         cin.get();
    }
     

    从上面的代码来看,原来单纯结构化编程需要的一个链表进入全局指针在这里被类的静态成员指针所替代(类的静态成员完全可以替代全局变量),这个例子的理解重点主要是要注意观察类成员的析构顺序,通过对析构顺序的理解,使用析构函数来进行节点的脱链操作。

    为什么虚函数必须是非静态成员函数
    如果定义为虚函数,那么它就是动态绑定的,也就是在派生类中可以被覆盖的,这与静态成员函数的定义本身就是相矛盾的。

    ==
    主要有两个作用: 
         1、管理静态数据成员; 
         2、提供类范围的功能,即不需要对象来实现的功能。 
    比如Symbian中的NewL/LC方法就是static的

    ==
    使用static关键字声明的函数成员是静态的,静态成员函数同样也属于整个类,由同一个类的所有对象共同维护,为这些对象所共享。

    作为成员函数,它的访问属性可以受到类的严格控制,对于公有的静态函数成员函数,可以通过类名或对象名来调用,但一般情况下建议用对象名来引用静态函数成员(真的吗?)。注意,一般的成员函数只能通过对象名来调用。
    由于一个类的静态成员函数只有一个拷贝,因此它访问对象的数据何函数使受到了限制。静态成员函数可以直接访问该类的静态数据成员。而访问非静态数据成员,必须通过参数传递方式得到对象名,然后通过对象名来访问。可以看到,通过静态函数成员访问非静态成员使相当麻烦的,一般的使用中,它主要用来访问全局变量或同一个类中的静态数据成员,特别是和后者一起使用,达到对同一个类中对象之间共享的数据进行维护的目的。
    构造函数不可以定义为static看了上面,应该可以理解原因。

    注意,由于static不是函数类型中的一部分,所以在类定义之外定义静态成员函数时不使用static,在类中定义的静态成员函数是内联的。

    一般来说,通过成员名限定比使用对象名访问静态成员要好。因为静态成员不是对象的成员。

    静态成员可以被继承,这时,基类对象和派生类的对象共享该静态成员,除此之外,在类等级中对静态成员的其他特性(例如,静态成员在派生类中的访问权限,在派生类中重载成员函数等)的分析与一般成员类似。

    静态成员函数不能被申明为虚函数,静态成员具有外部连接属性,static仅有的含义是使该成员为该类的所有对象共享。

    类中的任何成员函数都可以访问静态成员,但静态成员函数只能通过对象名(或指向对象的指针)访问该对象的非静态成员,因为静态成员函数没有this 指针。


    虚函数必须是非静态成员函数
    构造函数不可以定义为static

    展开全文
  • 静态函数可以分为全局静态函数和类的静态成员函数。 Static关键字 在类中,用static声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化,对于该类的所有对象来说,static成员变量只有一份...

    静态函数
    用static声明的函数是静态函数。静态函数可以分为全局静态函数类的静态成员函数

    Static关键字
    在类中,用static声明的成员变量为静态成员变量,它为该类的公用变量,在第一次使用时被初始化对于该类的所有对象来说,static成员变量只有一份
    用static声明的方法是静态方法,在调用该方法时,不会将对象的引用传递给它,所以在static方法中不可访问非static的成员。
    静态方法不再是针对于某个对象调用,所以不能访问非静态成员。

    可以通过对象引用或类名(不需要实例化)访问静态成员

    C++类静态数据成员与类静态成员函数
    函数调用的结果不会访问或者修改任何对象(非static)数据成员
    ,这样的成员声明为静态成员函数比较好。且如果static int func(....)不是出现在类中,则它不是一个静态成员函数,只是一个普通的全局函数,只不过由于static的限制,它只能在文件所在的编译单位内使用,不能在其它编译单位内使用。
    静态成员函数的声明除了在类体的函数声明前加上关键字static,以及不能声明为const或者volatile之外,与非静态成员函数相同。出现在类体之外的函数定义不能制定关键字static。
    静态成员函数没有this指针

    在没有讲述本章内容之前如果我们想要在一个范围内共享某一个数据,那么我们会设立全局对象,但面向对象的程序是由对象构成的,我们如何才能在类范围内共享数据呢?

    这个问题便是本章的重点:声明为static的类成员或者成员函数便能在类的范围内共同享我们把这样的成员称做静态成员和静态成员函数。

    下面我们用几个实例来说明这个问题,类的成员需要保护,通常情况下为了不违背类的封装特性,我们是把类成员设置为protected(保护状态)的,但是我们为了简化代码,使要说明的问题更为直观,更容易理解,我们在此处都设置为public。

    以下程序我们来做一个模拟访问的例子,在程序中,每建立一个对象我们设置的类静态成员变自动加一,代码如下:

    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class Internet  
    5. {  
    6. public:  
    7.      Internet(char *name,char *address)  
    8.      {  
    9.          strcpy(Internet::name,name);  
    10.          strcpy(Internet::address,address);  
    11.          count++;  
    12.      }   
    13.   
    14.      static void Internet::Sc()//静态成员函数  
    15.      {  
    16.          cout<<count<<endl;  
    17.      }  
    18.   
    19.      Internet &Rq();   
    20.   
    21. public:  
    22.      char name[20];  
    23.      char address[20];  
    24.      static int count;//这里如果写成static int count=0;就是错误的  
    25. };  
    26.   
    27. Internet& Internet::Rq()//返回引用的成员函数  
    28. {  
    29.      return *this;  
    30. }  
    31.   
    32. int Internet::count = 0;//静态成员的初始化  
    33.   
    34. void vist()  
    35. {  
    36.      Internet a1("中国软件开发实验室","www.cndev-lab.com");  
    37.      Internet a2("中国软件开发实验室","www.cndev-lab.com");  
    38. }   
    39.   
    40. void fn(Internet &s)  
    41. {  
    42.      cout<<s.Rq().count;  
    43. }  
    44.   
    45. void main()  
    46. {  
    47.      cout<<Internet::count<<endl;//静态成员值的输出  
    48.      vist();  
    49.      Internet::Sc();//静态成员函数的调用  
    50.      Internet b("中国软件开发实验室","www.cndev-lab.com");  
    51.      Internet::Sc();  
    52.      fn(b);  
    53.      cin.get();  
    54. }  



    上面代码我们用了几种常用的方式建立对象,当建立新对象并调用其构造函数的时候,静态成员cout便运行加1操作,静态成员的初始化应该在主函数调用之前,并且不能在类的声明中出现,通过运行过程的观察我们发现,静态成员count的状态并不会随着一个新的对象的新建而重新定义,尽而我们了解到类的静态成员是属于类的而不是属于哪一个对象的,所以静态成员的使用应该是类名称加域区分符加成员名称的,在上面的代码中就是Internet::count,虽然我们仍然可以使用对象名加点操作符号加成员名称的方式使用,但是不推荐的,静态类成员的特性就是属于类而不专属于某一个对象。

    静态成员函数的特性类似于静态成员的使用,同样与对象无关,调用方法为类名称加域区分符加成员函数名称,在上面的代码中就是Internet::Sc();静态成员函数由于与对象无关系,所以在其中是不能对类的普通成员进行直接操作的。

    如果上面的 static void Internet::Sc()修改成为:

    1. static void Internet::Sc()//静态成员函数  
    2. {  
    3.     cout<<name<<endl;//错误  
    4.      cout<<count<<endl;  
    5. }  



    静态成员函数与普通成员函数的差别就在于缺少this指针,没有这个this指针自然也就无从知道name是哪一个对象的成员了。

    根据类静态成员的特性我们可以简单归纳出几点,静态成员的使用范围:
    1.用来保存对象的个数。
    2.作为一个标记,标记一些动作是否发生,比如:文件的打开状态,打印机的使用状态,等等。
    3.存储链表的第一个或者最后一个成员的内存地址。

    为了做一些必要的练习,深入的掌握静态对象的存在的意义,我们以前面的结构体的教程为基础,用类的方式描述一个线性链表,用于存储若干学生的姓名,代码如下:

    1. #include <iostream>  
    2. using namespace std;  
    3.   
    4. class Student  
    5. {  
    6. public:  
    7.      Student (char *name);  
    8.      ~Student();  
    9.   
    10. public:  
    11.      char name[30];  
    12.      Student *next;  
    13.      static Student *point;  
    14. };  
    15.   
    16. Student::Student(char *name)  
    17. {  
    18.      strcpy(Student::name,name);  
    19.      this->next=point;  
    20.      point=this;  
    21. }  
    22.   
    23. Student::~Student ()//析构过程就是节点的脱离过程  
    24. {  
    25.      cout<<"析构:"<<name<<endl;  
    26.   
    27.      if(point==this)  
    28.      {  
    29.          point=this->next;  
    30.          cin.get();  
    31.          return;  
    32.      }  
    33.   
    34.      for(Student *ps=point;ps;ps=ps->next)  
    35.      {  
    36.          if(ps->next==this)  
    37.          {  
    38.          cout<<ps->next<<""<<this->next<<endl;  
    39.          ps->next=next;//=next也可以写成this->next;  
    40.          cin.get();  
    41.          return;  
    42.          }  
    43.      }  
    44.   
    45.      cin.get();  
    46. }  
    47.   
    48. Student* Student::point=NULL;  
    49. void main()  
    50. {  
    51.      Student *c = new Student("marry");  
    52.      Student a("colin");  
    53.      Student b("jamesji");  
    54.      delete c;  
    55.      Student *fp=Student::point;  
    56.      while(fp!=NULL)  
    57.      {  
    58.          cout<<fp->name<<endl;  
    59.          fp=fp->next;  
    60.      }  
    61.   
    62.      cin.get();  
    63. }   
    64.   
    65.   
    66. <span style="font-size:14px;">从上面的代码来看,原来单纯结构化编程需要的一个链表进入全局指针在这里被类的静态成员指针所替代(类的静态成员完全可以替代全局变量),这个例子的理解重点主要是要注意观察类成员的析构顺序,通过对析构顺序的理解,使用析构函数来进行节点的脱链操作。  
    67.   
    68. <strong><span style="color:maroon;">为什么虚函数必须是非静态成员函数</span></strong>  
    69. 如果定义为虚函数,那么它就是动态绑定的,也就是在派生类中可以被覆盖的,这与静态成员函数的定义本身就是相矛盾的。  
    70.   
    71. ==  
    72. 主要有两个作用:   
    73.      1、管理静态数据成员;   
    74.      2、提供类范围的功能,即不需要对象来实现的功能。   
    75. <strong><span style="color:red;">比如Symbian</span>中的NewL/LC方法就是static的</strong>  
    76.   
    77. ==  
    78. 使用static关键字声明的函数成员是静态的,静态成员函数同样也属于整个类,由同一个类的所有对象共同维护,为这些对象所共享。  
    79.   
    80. 作为成员函数,它的访问属性可以受到类的严格控制,对于公有的静态函数成员函数,可以通过类名或对象名来调用,但一般情况下建议用对象名来引用静态函数成员<strong><span style="color:blue;">(真的吗?)</span></strong>。注意,一般的成员函数只能通过对象名来调用。  
    81. 由于一个类的静态成员函数只有一个拷贝,因此它访问对象的数据何函数使受到了限制。静态成员函数可以直接访问该类的静态数据成员。而<strong>访问非静态数据成员,必须通过参数传递方式得到对象名,然后通过对象名来访问</strong>。可以看到,通过静态函数成员访问非静态成员使相当麻烦的,一般的使用中,它主要用来访问全局变量或同一个类中的静态数据成员,特别是和后者一起使用,达到对同一个类中对象之间共享的数据进行维护的目的。  
    82. <strong><span style="color:red;">构造函数不可以定义为static</span>,</strong>看了上面,应该可以理解原因。  
    83.   
    84. 注意,由于static不是函数类型中的一部分,所以在类定义之外定义静态成员函数时不使用static,在类中定义的静态成员函数是内联的。  
    85.   
    86. 一般来说,通过成员名限定比使用对象名访问静态成员要好。因为静态成员不是对象的成员。  
    87.   
    88. <strong><span style="color:red;">静态成员可以被继承</span></strong>,这时,基类对象和派生类的对象共享该静态成员,除此之外,在类等级中对静态成员的其他特性(例如,静态成员在派生类中的访问权限,在派生类中重载成员函数等)的分析与一般成员类似。  
    89.   
    90. <strong><span style="color:red;">静态成员函数不能被申明为虚函数</span></strong>,静态成员具有外部连接属性,static仅有的含义是使该成员为该类的所有对象共享。  
    91.   
    92. <strong>类中的任何成员函数都可以访问静态成员,但静态成员函数只能通过对象名(或指向对象的指针)访问该对象的非静态成员,因为静态成员函数没有this 指针。</strong></span><strong>  
    93.   
    94. <span style="color:#339966;">  
    95. </span><strong><span style="font-size:14px;color:#ff6600;">虚函数必须是非静态成员函数</span></strong></strong><span style="color:#ff6600;">  
    96. </span><strong><span style="font-size:14px;color:#ff6600;">构造函数不可以定义为static</span></strong>  
    为什么虚函数必须是非静态成员函数 构造函数能为static吗?

    转载于:https://www.cnblogs.com/qianggezhishen/p/7349496.html

    展开全文
  • 静态成员函数访问构造函数

    千次阅读 2017-04-08 00:16:27
    C++中,静态成员函数可以访问静态成员变量和静态成员函数,因为类的非静态成员函数会传入一个隐藏的this指针,这是大家都知道的。非静态的成员函数是属于类的,不属于某个对象,所以不含有this指针,所以只能调用...

    C++中,静态成员函数可以访问静态成员变量和静态成员函数,因为类的非静态成员函数会传入一个隐藏的this指针,这是大家都知道的。静态的成员函数是属于类的,不属于某个对象,所以不含有this指针,所以只能调用静态成员函数和静态成员变量,但是今天在实现单例模式(一个类只能拥有一个对象时发现静态成员函数可以访问构造函数,难道构造函数是静态的吗?)

    class Signalleton{
    public:
    	static Signalleton* get_instance();
    	void set_var(int var);
    	int get_var();
    private:
    	Signalleton();
    	virtual ~Signalleton();
    	static Signalleton *signal;
    	int _var;
    };
    
    Signalleton* Signalleton::signal = NULL;
    
    
    Signalleton* Signalleton::get_instance()
    {
    	if (NULL == signal)
    	{
    		signal = new Signalleton();
    	}
    	return signal;
    }  //静态成员函数访问了构造函数
    

    静态成员函数访问了构造函数,因为编译器做了扩展signa = new Signalleton; //分配内存 signal ->Signalleton::Signalleton(); //获得了this指针,调用构造函数
    如果静态函数能获得this指针就能访问非静态的成员函数;静态成员函数能够访问全局变量,静态成员变量和形参。

    展开全文
  • 1一般类静态成员函数不能调用非静态成员函数 2 static成员函数可以调用构造函数吗? 答案是肯定的,由于static成员函数没有this指针,所以一般static成员函数是不能访问non-static成员的,包括成员函数和成员变量...
  • 代码如下: ...//这里每调用一次构造函数不就重新刷新一次B了吗?用这种方法记录生成对象的个数??}static void f1(M m);private:int A;static int B;};void M::f1(M m){cout<<"A="<<m....
  • 静态是随着累的加载而加载的 也就是说类只要存在了,那么静态就存在了,而静态是优先于对象存在的 ,要访问非静态的东西,也就是非静态成员(包括变量和方法),非静态的东西还没存在你怎么访问的到吗?...
  • 1.this指针存在哪里? 其实编译器在生成程序时加入了获取对象首地址的...类的静态成员函数因为没有this指针这个参数,所以类的静态成员函数也就无法调用类的非静态成员变量。 2.this指针可以为空吗? 可以为空,当...
  • this指针存在哪里? 其实编译器在生成程序时加入了获取对象首地址的相关代码。...类的静态成员函数因为没有this指针这个参数,所以类的静态成员函数也就无法调用类的非静态成员变量 this指针可以...
  • const对象可以调用非const成员函数吗? 非const对象可以调用const成员函数吗? const成员函数内可以调用其它的非const成员函数吗? 非const成员函数内可以调用其它的const成员函数吗? static访问权限...
  • C++基础复习

    2020-09-05 21:57:11
    this指针可以为空吗类的6大默认成员函数默认构造函数初始化列表注意初始化顺序静态成员特性静态成员函数可以调用非静态成员函数吗友元函数友元类内部类C++内存分布new/delete与malloc/free的区别什么是内存泄漏,...
  • 在Java中,当实例化对象时,对象所在类的所有成员变量首先要进行初始化,只有当所有类成员初始化后,才会调用对象所在类的构造函数创建对象 。 二、Java程序的初始化一般遵循3个原则 优先级依次递减 静态变量(对象...
  • C++面试题之问题归纳

    2020-09-11 18:19:14
    基础知识点 ...7.类的静态成员与非静态成员有哪些区别? 8.说说纯虚函数,虚函数,多态(虚指针,虚函数表),this指针 9.说说堆和栈(内存布局,内核空间,用户空间) 10.重载,重写(覆盖)与隐藏的区别
  • this指针

    2019-05-29 23:23:58
    1.this指针存在哪里? 其实编译器在生成程序时加入了获取对象首地址的相关代码...类的静态成员函数因为没有this指针这个参数,所以类的静态成员函数也就无法调用类的非静态成员变量。 2.this指针可以为空吗? 可...
  • 孩子王面试经验

    千次阅读 2018-08-29 17:15:11
    1.static函数可以调用类的非静态变量吗? 不能,static函数中没有this指针,所以不能调用某个具体对象的非static成员 2.多态性的理解?怎么实现? STL: 1.STL标准模板库中都有什么? IO库/顺序容器/泛型算法...
  • 17.3 静态成员函数 349 17.4 静态成员的使用 351 17.5 函数指针 353 17.6 函数指针数组 357 17.7 函数指针也可以作为函数的参数 359 17.8 使用typedef简化函数指针的声明及定义 361 17.9 类的函数指针 363 ...
  • 4.4.3 结构可以将string类作为成员吗 4.4.4 其他结构属性 4.4.5 结构数组 4.4.6 结构中的位字段 4.5 共用体 4.6 枚举 4.6.1 设置枚举量的值 4.6.2 枚举的取值范围 4.7 指针和自由存储空间 4.7.1 声明和初始...
  • 零起点学通C++多媒体范例教学代码

    热门讨论 2010-11-30 09:35:13
    13.9.1 在虚函数调用成员函数 13.9.2 3种调用函数的方式比较 13.10被继承的虚函数仍然是虚函数 13.11系统是如何调用函数的 13.12在虚函数中使用成员名限定 13.13虚析构函数 13.14总结 第14章 数组 14.1 数组...
  • 13.9.1 在虚函数调用成员函数 13.9.2 3种调用函数的方式比较 13.10被继承的虚函数仍然是虚函数 13.11系统是如何调用函数的 13.12在虚函数中使用成员名限定 13.13虚析构函数 13.14总结 第14章 数组 ...
  • 数据信息可分为数值信息和数值信息两类。 1-8 什么叫二进制?使用二进制有何优点和缺点? 解: 二进制是基数为2,每位的权是以2 为底的幂的进制,遵循逢二进一原则,基本符号为0和1。采用二进制码表示信息,有...
  • 面试题126 一个类可以访问另一个类的私有成员吗 11.4 函数重载 面试题127 函数重载与作用域 面试题128 如何进行函数重载的匹配 面试题129 函数重载时如何实现实参的类型转换 第12章 模板与STL( 教学视频:46分钟) ...

空空如也

空空如也

1 2 3 4 5
收藏数 85
精华内容 34
关键字:

静态函数可以调用非静态成员吗