精华内容
下载资源
问答
  • 2、静态成员变量 3、静态常成员变量(基本数据类型) 4、静态常成员变量(自定义数据类型) 二、常成员变量 C++中使用const关键字修饰的成员变量就是常成员变量,有两种定义方式: const int c; int const c...

    一、引言

    C++中类的成员变量有以下几种特殊的类型:

    1、常成员变量

    2、静态成员变量

    3、静态常成员变量(基本数据类型)

    4、静态常成员变量(自定义数据类型)

    二、常成员变量

    C++中使用const关键字修饰的成员变量就是常成员变量,有两种定义方式:

    const int c;

    int const c;

    需要注意的是:

    1)任何函数都不可以对其值进行赋值和修改;

    2)必须而且只能在构造函数的成员初始化列表中对其进行初始化

    3)假如类有多个构造函数,必须在所有的构造函数中都对其进行初始化。

    三、静态成员变量

    C++中使用static关键字修饰的成员变量就是静态成员变量,有两种定义方式:

    static int c;

    int static c;

    需要注意的是:

    1)在类外进行初始化,并且在初始化时不需要在加static进行修饰

    2)不可以放在xxx.h文件中进行初始化,必须放在xxx.cpp文件中,否则会造成重复定义

    3)静态变量在程序开始运行时就已经分配了空间以及初始化了,并不属于类的某一个实例对象;静态成员变量被所有的对象共享,包括该类的派生类对象;

    4)静态变量可以被类中所有的函数调用并修改,如果是public类型,也可以通过类名对其进行访问和修改;

    5)静态变量的类型可以是所属类的类型(不知道有什么用),而普通成员只能声明为所属类类型的指针或者引用;

     

    四、静态常成员变量

    使用staticconst类修饰的成员变量

    对于不同的数据类型,其初始化形式有所不同:

    1、自定义类型(string等内置类型以及使用class定义的类等)

          必须放在类外初始化,不可以放在xxx.h文件中,可以不加static修饰

    2、基本数据类型(intdouble float bool等)

          可以在类内部进行初始化(唯一一个可以在类内进行初始化的)

    五、例程

    example.h文件

    class Example{
    public:
        Example();
    private:
        int i;
        static int si;
        const int ci;	//常成员变量,在构造函数的初始化列表中初始化
        static const double scd = 1.01;
        static const int sci;
        static const string scs;	//类类型的静态常量,必须在类外初始化
    };
    
    example.cpp文件

    int Example::si = 10;
    const int Example::sci = 19;
    const string Example::scs = "zs";
    Example::Example():i(1),ci(19){} //对常成员变量ci进行初始化
    




    展开全文
  • 类的静态成员及private修饰的静态成员的使用方法小结: -静态成员变量在类中仅仅声明,没有定义,所以要在类的外面定义,实际上静态成员变量分配内存; -静态成员函数和静态数据成员,定义时,不需要加...

    类的静态成员及private修饰的静态成员的使用方法小结

    - 静态成员变量在类中仅仅是声明,没有定义,所以要在类的外面定义,实际上是给静态成员变量分配内存;

    - 静态成员函数和静态数据成员,定义时,不需要加static修饰符,否则会报错:"Cannot declare member function ...to have static linkage";

    public方法可访问static成员;static方法只能访问static成员

    - 在pubic方法中,static成员可以用this指针访问(默认隐去this指针);static方法中不能使用this指针

    private修饰的静态成员函数和静态数据成员,只能在类的内部使用

     

    测试代码:static_test.cpp,在相应代码后有注释说明。

    #include <iostream>
    using namespace std;
     
    class test
    {
    public:
    	int k;
    	static int i;
    	test() {k=0;}
    	void print();
    	void call_static_fun();
    	static void print_j();
    private:
    	static int j;
    };
    
    int test::i = 0;
    int test::j = 0;
    
    //public方法访问static成员 
    void test::print()
    {
    	cout << ">>: run  print() :" << endl;
    
    	cout << "print() i = "<< i << endl;
    	cout << "print() j = "<< this->j << endl;//此处加不加this都可以
    	print_j();
    	
    }
     
    //static方法访问static成员 
    void test::call_static_fun()
    {
    	cout << ">>: run  call_static_fun() :" << endl;
    
    	cout << "call_static_fun() j = "<< j << endl;
    	this->print_j();
    }
    
    //static方法访问public测试
    void test::print_j()
    {
    	cout << ">>: run  print_j() :" << endl;
    	// cout << "print_j():k = "<< this->k << endl;//错误!!!static方法中没有this指针
    	// cout << "print_j():k = "<< k << endl;//错误!!!static方法只能访问static成员
    	//print();//错误!!!static方法只能访问static成员
    }
    
    
    int main()
    {
    	test t;
    	t.print();
    	t.call_static_fun();
    
    
    	cout << "main : i = "<< t.i << endl;//static数据成员的访问
    	//cout << "j = "<< t.j << endl;//错误!!! private修饰的static成员不能在类外访问
    	test::print_j();//static方法的访问
    	t.print_j();//static方法的访问
    	
    	return 0;
    }
    
    
    g++ -o staic_test.o static_test.cpp 

    输出:

    yuan@linx-c:~/VSCode/CPP_Learning/static_test$ ./staic_test.o 
    >>: run  print() :
    print() i = 0
    print() j = 0
    >>: run  print_j() :
    >>: run  call_static_fun() :
    call_static_fun() j = 0
    >>: run  print_j() :
    main : i = 0
    >>: run  print_j() :
    >>: run  print_j() :
    

    注释部分相关报错

    error: ‘this’ is unavailable for static member functions
      cout << "print_j():k = "<< this->k << endl;
    
    error: invalid use of member ‘test::k’ in static member function
      cout << "print_j():k = "<< k << endl;
    
    
    error: cannot call member function ‘void test::print()’ without object
      print();

     

     

     

    展开全文
  • 静态成员:静态类中成员加入 static 修饰符,即是静态成员.可以直接使用类名+静态成员名 访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态 成员不能访问非静态成员..因为静态...
    静态成员:静态类中的成员加入 static 修饰符,即是静态成员.可以直接使用类名+静态成员名 访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态 成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中 静态的成员.
    非成静态员:所有没有加 Static 的成员都是非静态成员,当类被实例化之后,可以通过实例化 的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的 概念,因为静态成员始终驻留在内容中.. 一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数.. 分两个方面来总结,第一方面主要是相对于面向过程而言,即在这方面不涉及到类,第二方 面相对于面向对象而言,主要说明 static 在类中的作用。
    一、在面向过程设计中的 static 关键字
    1、静态全局变量 定义:在全局变量前,加上关键字 static 该变量就被定义成为了一个静态全局变量。 特点:
    A、该变量在全局数据区分配内存。
    B、初始化:如果不显式初始化,那么将被隐式初始化为 0(自动变量是随机的,除非显式 地初始化)。
    C、访变量只在本源文件可见,严格的讲应该为定义之处开始到本文件结束。
     
    例(摘于 C++程序设计教程---钱能主编 P103)
    //file1.cpp :
    //Example 1
    #include <iostream.h>
     void fn();
    static int n; //定义静态全局变量
    void main()
    {
    n=20; cout < <n < <endl;
    fn();
    }
    void fn()
    {
    n++;
    cout < <n < <endl;
    }
    D、文件作用域下声明的 const 的常量默认为 static 存储类型。
    静态变量都在全局数据区分配内存, 包括后面将要提到的静态局部变量。 对于一个完整的程 序,在内存中的分布情况如下图:
    代码区
    全局数据区
    堆区
    栈区
     
        一般程序的由 new 产生的动态数据存放在堆区,函数内部的自动变量存放在栈区。自 动变量一般会随着函数的退出而释放空间,静态数据(即使是函数内部的静态局部变量)也 存放在全局数据区。 全局数据区的数据并不会因为函数的退出而释放空间。 细心的读者可能 会发现,Example 1 中的代码中将 static int n; //定义静态全局变量 改为: int n; //定义全局变量程序照样正常运行。的确,定义全局变量就可以实现变量在文件中的共 享,但定义静态全局变量还有以下好处: 静态全局变量不能被其它文件所用;(好像是区别 extern 的) 其它文件中可以定义相同名字的变量,不会发生冲突; 您可以将上述示例代码改为如下:
     
    //Example 2
    //File1
     #include <iostream.h>
    void fn();
    static int n; //定义静态全局变量(只能在本文件中使用)
    void main()
    {
     n=20;
    cout << n <<endl;
    fn();
    }
     
     
    //File2 #include <iostream.h> extern int n;(可在别的文件中引用这个变量) void fn() { n++; cout < <n < <endl; } 编译并运行 Example 2,您就会发现上述代码可以分别通过编译,但 link 时出现错误。试着 将 static int n; //定义静态全局变量 改为 int n; //定义全局变量 再次编译运行程序,细心体会全局变量和静态全局变量的区别。 2、静态局部变量 定义:在局部变量前加上 static 关键字时,就定义了静态局部变量。我们 先举一个静态局部变量的例子,如下:
    //Example 3
    #include <iostream.h>
     void fn();
    void main()
    {
    fn(); fn(); fn();
    }
    void fn()
    {
    static n=10;
    cout < <n < <endl;
    n++;
    }
     
        通常, 在函数体内定义了一个变量, 每当程序运行到该语句时都会给该局部变量分配栈 内存。但随着程序退出函数体,系统就会收回栈内存,局部变量也相应失效。 但有时候我们需要在两次调用之间对变量的值进行保存。 通常的想法是定义一个全局变 量来实现。但这样一来,变量已经不再属于函数本身了,不再仅受函数的控制,给程序的维 护带来不便。 静态局部变量正好可以解决这个问题。 静态局部变量保存在全局数据区, 而不是保存在 栈中,每次的值保持到下一次调用,直到下次赋新值。
     
    特点: A、该变量在全局数据区分配内存。 B、初始化:如果不显式初始化,那么将被隐式初始化为 0,以后的函数调用不再进行初 始化。 C、它始终驻留在全局数据区,直到程序运行结束。但其作用域为局部作用域,当定义 它的函数或 语句块结束时,其作用域随之结束。 3、静态函数(注意与类的静态成员函数区别) 定义:在函数的返回类型前加上 static 关键字,函数即被定义成静态函数。
    特点: A.静态函数与普通函数不同,它只能在声明它的文件当中可见,不能被其它文件使用。 静 态函数的例子:
     //Example 4
    #include <iostream.h>
    static void fn();//声明静态函数
    void main()
    {
    fn();
    }
    void fn()//定义静态函数
    {
    int n=10; cout < <n < <endl;
    }
     
        定义静态函数的好处:静态函数不能被其它文件所用; 其它文件中可以定义相同名字的函数,不会发生冲突; 二、面向对象的 static 关键字(类中的 static 关键字) 1、静态数据成员 在类内数据成员的声明前加上关键字 static,该数据成员就是类内的静态数据成员。先举一 个静态数据成员的例子。
    //Example 5
    #include <iostream.h>
     class Myclass
    {
    public: Myclass(int a,int b,int c);
    void GetSum();
    private: int a,b,c;
    static int Sum;//声明静态数据成员
    };
    int Myclass::Sum=0;//定义并初始化静态数据成员
    Myclass::Myclass(int a,int b,int c)
    {
    this->a=a; this->b=b; this->c=c; Sum+=a+b+c;
    }
    void Myclass::GetSum()
    {
    cout < <"Sum=" < <Sum < <endl; }
    void main()
    {
    Myclass M(1,2,3);
     M.GetSum();
    Myclass N(4,5,6);
     N.GetSum();
    M.GetSum();
     
    }
     
     
     
    可以看出,静态数据成员有以下特点: 
    (1) 对于非静态数据成员, 每个类对象都有自己的拷贝。 而静态数据成员被当作是类的成员。 无论这个类的对象被定义了多少个, 静态数据成员在程序中也只有一份拷贝, 由该类型 的所有对象共享访问。也就是说,静态数据成员是该类的所有对象所共有的。对该类的 多个对象来说,静态数据成员只分配一次内存,供所有对象共用。所以,静态数据成员 的值对每个对象都是一样的,它的值可以更新;
    (2) 静态数据成员存储在全局数据区。 静态数据成员定义时要分配空间, 所以不能在类声明 中定义。在 Example 5 中,语句 int Myclass::Sum=0;是定义静态数据成员;
    (3) 静态数据成员和普通数据成员一样遵从 public,protected,private 访问规则;
    (4) 因为静态数据成员在全局数据区分配内存,属于本类的所有对象共享,所以,它不属于 特定的类对象,在没有产生类对象时其作用域就可见,即在没有产生类的实例时,我们 就可以操作它;
     
         静态数据成员初始化与一般数据成员初始化不同。静态数据成员初始化的格式为: <数据类型><类名>::<静态数据成员名>=<值> 类的静态数据成员有两种访问形式: <类对象名>.<静态数据成员名> 或 <类类型名>::<静态数据成员名> 如果静态数据成员的访问权限允许的话(即 public 的成员) ,可在程序中,按上述格式来引 用静态数据成员 ; 静态数据成员主要用在各个对象都有相同的某项属性的时候。 比如对于一个存款类, 每个实 例的利息都是相同的。 所以, 应该把利息设为存款类的静态数据成员。 这有两个好处, 第一, 不管定义多少个存款类对象, 利息数据成员都共享分配在全局数据区的内存, 所以节省存储 空间。 第二, 一旦利息需要改变时, 只要改变一次, 则所有存款类对象的利息全改变过来了;
     同全局变量相比,使用静态数据成员有两个优势:
    (1) 静态数据成员没有进入程序的全局名字空间, 因此不存在与程序中其它全局名字冲突的 可能性;
    (2) 可以实现信息隐藏。静态数据成员可以是 private 成员,而全局变量不能;
     
    2、静态成员函数 与静态数据成员一样, 我们也可以创建一个静态成员函数, 它为类的全部服务而不是为 某一个类的具体对象服务静态成员函数与静态数据成员一样,都是类的内部实现,属于类 定义的一部分。普通的成员函数一般都隐含了一个 this 指针,this 指针指向类的对象本身, 因为普通成员函数总是具体的属于某个类的具体对象的。通常情况下,this 是缺省的。如函 数 fn()实际上是 this->fn()。但是与普通函数相比,静态成员函数由于不是与任何的对象相联 系,因此它不具有 this 指针。从这个意义上讲,它无法访问属于类对象的非静态数据成员, 也无法访问非静态成员函数, 它只能调用其余的静态成员函数。 下面举个静态成员函数的例 子。
    //Example 6
    #include <iostream.h>
     class Myclass
    {
    public: Myclass(int a,int b,int c);
    static void GetSum();/声明静态成员函数
    private: int a,b,c; static int Sum;//声明静态数据成员
    };
    int Myclass::Sum=0;//定义并初始化静态数据成员
    Myclass::Myclass(int a,int b,int c)
    { this->a=a; this->b=b; this->c=c; Sum+=a+b+c; //非静态成员函数可以访问静态数据成员
    }
    void Myclass::GetSum() //静态成员函数的实现
    {
    // cout < <a < <endl; //错误代码,a 是非静态数据成员
    cout < <"Sum=" < <Sum < <endl;
    }
    void main()
    {
    Myclass M(1,2,3); M.GetSum(); Myclass N(4,5,6); N.GetSum(); Myclass::GetSum();
     }
     
     
    关于静态成员函数,可以总结为以下几点: 
    (1) 出现在类体外的函数定义不能指定关键字 static;
    (2) 静态成员之间可以相互访问,包括静态成员函数访问静态数据成员和访问静态成员函 数; 
    (3) 非静态成员函数可以任意地访问静态成员函数和静态数据成员; 
    (4) 静态成员函数不能访问非静态成员函数和非静态数据成员; 
    (5) 由于没有 this 指针的额外开销, 因此静态成员函数与类的全局函数相比速度上会有少许 的增长; 
    (6) 调用静态成员函数,可以用成员访问操作符(.)和(->)为一个类的对象或指向类对象的指 针调用静态成员函数;
    展开全文
  • 静态成员:静态类中成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态成员..因为静态成员...





    1.数据成员可以分静态变量非静态变量两种.
    静态成员:静态类中的成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态的成员..因为静态成员存在于内存,所以非静态成员可以直接访问类中静态的成员.静态成员在每个类中只有一个拷贝,是解决同一个类的不同对象之间数据和函数共享问题的。
     
     非成静态员:所有没有加Static的成员都是非静态成员,当类被实例化之后,可以通过实例化的类名进行访问..非静态成员的生存期决定于该类的生存期..而静态成员则不存在生存期的概念,因为静态成员始终驻留在内容中..
     

     一个类中也可以包含静态成员和非静态成员,类中也包括静态构造函数和非静态构造函数..

    2.

    静态成员函数可以直接引用该类的静态数据成员和静态成员函数,但不能直接引用非静态数据成员和非静态成员函数,否则编译报错。如果要引用,必须通过参数传递的方式得到对象名,然后再通过对象名引用
    1. class A  
    2. {  
    3.       public:  
    4.       static void f(A a);  
    5.      private:  
    6.           int x;  
    7. };  
    8. void A::f(A a)  
    9. {  
    10.       cout<<x<<endl;//对x的引用是错误的  
    11.      cout<<a.x<<endl;//正确的  
    12. }  
    class A
    {
          public:
    	  static void f(A a);
         private:
              int x;
    };
    void A::f(A a)
    {
          cout<<x<<endl;//对x的引用是错误的
         cout<<a.x<<endl;//正确的
    }
    例2:
    1. #include<iostream>  
    2. using namespace std;  
    3.   
    4. class Myclass  
    5. {  
    6.     private:  
    7.         int     m;  // 非静态数据成员  
    8.         static  int n;  // 静态数据成员  
    9.     public:  
    10.         Myclass();  // 构造函数  
    11.         static  int getn(Myclass a);    // 静态成员函数  
    12. };  
    13.   
    14. Myclass::Myclass()  
    15. {  
    16.     m = 10;  
    17. }  
    18.   
    19. int Myclass::getn(Myclass a)  
    20. {  
    21.     cout << a.m << endl;    // 通过类间接使用  非静态数据成员  
    22.     return n;       // 直接使用  静态数据成员  
    23. }  
    24.   
    25. int Myclass::n = 100;   // 静态数据成员初始化  
    26.   
    27. void    main()  
    28. {  
    29.     Myclass app1;  
    30.     cout << app1.getn(app1) << endl;    // 利用对象引用静态函数成员  
    31.     cout << Myclass::getn(app1) << endl;    // 利用类名引用静态函数成员  
    32. }  
    #include<iostream>
    using namespace std;
    
    class Myclass
    {
    	private:
    		int		m;	// 非静态数据成员
    		static	int	n;	// 静态数据成员
    	public:
    		Myclass();	// 构造函数
    		static	int	getn(Myclass a);	// 静态成员函数
    };
    
    Myclass::Myclass()
    {
    	m = 10;
    }
    
    int	Myclass::getn(Myclass a)
    {
    	cout << a.m << endl;	// 通过类间接使用  非静态数据成员
    	return n;		// 直接使用  静态数据成员
    }
    
    int	Myclass::n = 100;	// 静态数据成员初始化
    
    void	main()
    {
    	Myclass app1;
    	cout << app1.getn(app1) << endl;	// 利用对象引用静态函数成员
    	cout << Myclass::getn(app1) << endl;	// 利用类名引用静态函数成员
    }

    那么可以得出结论,静态成员和非静态成员区别如下:
    1.访问方式不一样.静态成员(通过类名.静态成员名访问).非静态成员(通过对象名.非静态成员名访问)
    2.静态成员属于类.该类的所有对象共同拥有这一个成员.
    非静态成员属于对象,每个对象都有一份.静态成员不论有类有多少个对象.只在内存中分配一块空间.
    展开全文
  • 静态成员在类所有对象中共享。如果不存在其他初始化语句,在创建第一个对象时,所有静态数据都会被初始化为 0。 静态成员在类中声明,在类外定义和初始化。在类外使用范围解析运算符 :: 来重新声明静态...
  • 对类内部数据成员和函数成员都可以用static修饰。 如果成员被static修饰,那该成员就是静态,从应用角度讲,类使用者通过类来访问静态成员在语义上更能够被理解,而通过实例来访问静态成员在语义上显得不合适...
  • 常成员和静态成员C++类成员中需要特殊记忆和对待,而这两个概念在中文上有些接近,容易混淆,因此特地整理一下,方便学习和记忆。 关键字解析 const,常类型,类型定义符,意味着值保持不变,作用对...
  • 平时在用C#做开发朋友都知道,不论是静态成员还是静态方法还是静态类都是用static关键字来修饰。static关键字也就是说只要看到了static,那么它后面东西就是静态!在c#中,静态成员或者静态方法是属于类,不是...
  • 块作用域中声明的,没有用static修饰的对象动态生存期的对象(习惯称局部生存期对象)。 开始于程序执行到声明点时,结束于命名该标识符的作用域结束处。 静态数据成员 用关键字static声明 为该类的所有对象...
  • final关键字最终的意思,可以修饰成员方法,成员变量,类 final修饰的特点 修饰方法:表明该方法时最终方法,不能被重写 修饰变量:表明该变量常量,不能再次被赋值 修饰类:表明该类最终类,不能被继承 ...
  • 静态数据成员需要单独初始化,而且在类外面。 静态成员函数不能调用非静态数据成员和非静态成员函数。 静态数据成员只有一份,且不依赖对象数量而存在。 静态成员函数不能用const修饰符。 普通成员函数可以...
  • 数据成员的修饰

    2007-05-25 11:47:00
    一 static修饰的静态数据成员 用static修饰的数据成员是不属于任何一个类的具体对象,而是属于类的静态数据成员,其特点如下: 它被保存在类的内存区的公共存储单元中,而不是保存在某个对象的内存区中,因些一个类的...
  • 静态成员函数不能用const修饰 ,也不能存取nonstatic数据C++中静态成员函数不能用const修饰的原因:static在c++中的第五种含义:用static修饰不访问非静态数据成员的类成员函数。这意味着一个静态成员函数只能访问它...
  • C++中静态数据成员

    2019-10-05 18:26:41
    类的静态成员不能由类的构造函数来初始化。因为即使不存在类的任何对象时,类的静态成员依然存在并且可以被使用。类的静态成员也不能访问任何...static修饰的函数表示该函数属于类的,而不是属于某一个对象的,没...
  • 静态数据成员[1] 用关键字static声明。...类的静态成员是用static修饰的,属于整个类,而不属于对象。例5-4 具有静态数据成员的Point类UML程序描述方式//5_4.cpp #include <iostream> usi...
  • 静态成员:静态类中成员加入 static 修饰符,即是静态成员.可以直接使用类名+静态成员名 访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态 成员不能访问非静态成员..因为静态...
  • 静态数据成员和函数

    2019-07-26 08:52:00
    (1)静态数据成员在同一个类的实例之间可以共享,如果不想让它共享,可以将它设为私有的或保护的。 (2)静态成员函数可以通过类名和对象名来调用, ...(5)被static修饰的成员函数不分配空间的。 (6)被st...
  • 静态数据成员由static关键字修饰,必须定义为私有成员,不能从类外访问,基本格式static+数据类型名+变量名;然而他初始化方法也与别不同,由:数据类型名 类名::静态数据成员名=值;静态数据成员的格式...
  • C++中静态成员函数不能用static修饰的原因: static在c++中的第五种含义:用static修饰不访问非静态数据成员的类成员函数。这意味着一个静态成员函数只能访问它的参数、类的静态数据成员和全局变量。  不能用...
  • C++静态成员和非静态成员的区别

    千次阅读 2018-07-20 15:43:14
    静态成员:静态类中成员加入static修饰符,即是静态成员.可以直接使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态成员..因为静态成员...
  • 静态成员:静态类中成员加入static 修饰符,即是静态成员,可以使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态成员,因为静态成员...
  • 静态成员:静态类中成员加入static修饰符,即是静态成员,可以使用类名+静态成员名访问此静态成员,因为静态成员存在于内存,非静态成员需要实例化才会分配内存,所以静态成员不能访问非静态成员,因为静态成员...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,563
精华内容 625
关键字:

修饰的数据成员是静态成员