精华内容
下载资源
问答
  • 一、引言 C++中类的成员变量有以下几种...C++中使用const关键字修饰的成员变量就是常成员变量,有两种定义方式: const int c; int const c; 需要注意的是: 1)任何函数都不可以对其值进行赋值和修改; 2)必

    一、引言

    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进行初始化
    




    展开全文
  • 【C++】 对象、常数据成员成员函数总结

    千次阅读 多人点赞 2019-03-24 15:07:25
    常数据成员  ◆ 常数据成员必须进行初始化,并且不能被更新。  ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),常数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始...
    常数据成员

     ◆ 常数据成员必须进行初始化,并且不能被更新。

     ◆ 常数据成员不能在声明时赋初始值(普通数据成员也是),常数据成员必须在构造函数初始化列表进行初始化;普通数据成员在初始化列表和函数体中初始化均可。

     ◆ PS:类的成员对象若要传入参数初始化,则必须在构造函数初始化列表进行;(成员对象:当一个类的成员是另一个类的对象时,这个对象就叫成员对象。)

    常对象

     ◆ ⭐常对象可以调用常成员函数,不能调用非const成员函数;非const对象,可以调用普通成员函数和常成员函数。

     ◆ 常对象的成员函数不一定都是常成员函数;同样的常对象的数据成员不一定都是常数据成员。

     ◆ 常对象一旦初始化,常对象的数据成员便不允许修改,而不是说常对象的数据成员都是常数据成员。

     ◆ PS:定义常对象有两种方法,1. Point const a; 2. const Point a;(同样的,定义变量或指针时,const放前放后意义一样,如:1. const double a; double const a; 2. const int *p; int const *p; 但是定义指针常量时,只能用 int * const p;)

    常成员函数

     ◆ 常成员函数不更新对象的数据成员。

     ◆ 常成员函数的const关键字可以被用于参与对重载函数的区分。

     ◆ ⭐通常非const成员函数需要定义一个const版本的重载函数,以方便定义常对象后调用常成员函数。
      ◈ 如果常对象调用的常成员函数返回的是指向当前对象的指针(或返回的是当前对象),那么此常成员函数的声明的返回类型要加const,例如:

        ◊ 成员函数返回指向当前对象的指针
          const *Point fun1();    //非const成员函数的类内声明;
          const *Point fun1() const; //习惯上要再声明一个常成员函数作重载函数,注意到此函数声明有两个const;

        ◊ 成员函数返回指向当前对象
          const Point fun1();    //非const成员函数的类内声明;
          const Point fun1() const; //习惯上要再声明一个常成员函数作重载函数,注意到此函数声明有两个const;

        ◊ ⭐注意,如果一个类中声明以下4个重载函数:
          ① Point fun1();
          ② const Point fun1();
          ③ Point fun1() const;
          ④ const Point fun1() const;
         【解析】①和②是冲突的,因为无法区分仅按返回类型区分的重载函数;③和④是冲突的,也是因为无法区分仅按返回类型区分的重载函数。
         所以正确的重载函数搭配有3种:

          ◊ ①和③搭配:
            Point fun1();             //函数返回非const对象
            Point fun1() const;          //函数返回非const对象
           [解析]适用于定义常对象后调用常成员函数,常成员函数返回类型是非const的Point类对象。

          ◊ ①和④搭配(这里把返回类型改为指针,因为常用):
            Point *fun1() {return this; };      //函数返回指向本对象的指针
            const Point *fun1() const { return this; };//函数返回指向本常对象的指针,第一个const说明返回的是指向常对象的指针,第二个const说明此函数是常函数

           [解析]适用于定义常对象后调用常成员函数,常成员函数返回类型是常Point类对象(如return *this;)。

          ◊ ②和④搭配:
            const Point fun1();          //函数返回常对象
            const Point fun1() const;       //函数返回常对象
           [解析]适用于定义常对象后调用常成员函数,常成员函数返回类型是常Point类对象。

           ②和③搭配:
            const Point fun1();
            Point fun1() const;
           [解析]虽然搭配合法,但是似乎不存在这种搭配。

    展开全文
  • 类静态数据成员定义

    千次阅读 2017-09-11 09:13:52
    其实这句话“静态成员变量是需要初始化的”是有一定问题的,应该说“静态成员变量需要定义”才是准确的,而不是初始化。两者的区别在于:初始化是赋一个初始值,而定义是分配内存。静态成员变量在类中仅仅是声明,...

    转载自:http://blog.csdn.net/u011499425/article/details/52751636

    我们知道C++类的静态成员变量是需要初始化的,但为什么要初始化呢。其实这句话“静态成员变量是需要初始化的”是有一定问题的,应该说“静态成员变量需要定义”才是准确的,而不是初始化。两者的区别在于:初始化是赋一个初始值,而定义是分配内存。静态成员变量在类中仅仅是声明,没有定义,所以要在类的外面定义,实际上是给静态成员变量分配内存。可以通过以下几个例子更形象的说明这个问题:

    [cpp]  view plain  copy
    1. //test.cpp   
    2. #include <stdio.h>   
    3. class A {   
    4.     public:   
    5.         static int a; //声明但未定义  
    6.  };   
    7. int main() {   
    8.     printf("%d", A::a);  
    9.     return 0;  
    10. }  


    编译以上代码会出现“对‘A::a’未定义的引用”错误。这是因为静态成员变量a未定义,也就是还没有分配内存,显然是不可以访问的。再看如下例子:

    [cpp]  view plain  copy
    1. //test.cpp   
    2. #include <stdio.h>   
    3. class A {   
    4.     public:   
    5.         static int a; //声明但未定义  
    6.  };   
    7. int A::a = 3; //定义了静态成员变量,同时初始化。也可以写"int A:a;",即不给初值,同样可以通过编译  
    8. int main() {   
    9.     printf("%d", A::a);  
    10.     return 0;  
    11. }  


    这样就对了,因为给a分配了内存,所以可以访问静态成员变量a了。因为类中的静态成员变量仅仅是声明,暂时不需分配内存,所以我们甚至可以这样写代码:

    [cpp]  view plain  copy
    1. //a.cpp  
    2. class B; //这里我们使用前置声明,完全不知道B是什么样子  
    3. class A {  
    4.     public:  
    5.         static B bb;//声明了一个类型为B的静态成员,在这里编译器并未给bb分配内存。  
    6.                     //因为仅仅是声明bb,所以编译器并不需要知道B是什么样子以及要给其对应的对象分配多大的空间。  
    7.                     //所以使用前置声明"class B"就可以保证编译通过。  
    8. };  

    使用命令"g++ -c -o a.o a.cpp"通过编译。对于类来说,new一个类对象不仅会分配内存,同时会调用构造函数进行初始化,所以类对象的定义和初始化总是关联在一起。


    展开全文
  • C++类中的常数据成员和静态数据成员的区别

    千次阅读 多人点赞 2013-09-20 01:19:26
    常数据成员是指在类中定义的不能修改其值的一些数据成员,类似于我们以前学过的变量,虽然是变量,也有自己的地址,但是一经赋初值,便不能再被修改。 适用于类中定义一些初始化之后不希望被修改的变量。 定义方法...

    刚开始学习C++的类和对象的部分,对类中的常数据成员和静态数据成员的概念和用法经常混淆,所以今天整理一下,顺便说一下,今天是我的生日,祝我生日快乐,呵呵。

    常数据成员

    常数据成员是指在类中定义的不能修改其值的一些数据成员,类似于我们以前学过的常变量,虽然是变量,也有自己的地址,但是一经赋初值,便不能再被修改

    适用于类中定义一些初始化之后不希望被修改的变量。

    定义方法:

    const 类型名 变量名;

    (1)类中的常数据成员只能通过构造函数的参数初始化表进行初始化

    (2)常数据成员是实例化对象的一部分,可以用this指针访问。

    #include<iostream>
    using namespace std;
    class Happy_birthday
    {
    	public:
     		Happy_birthday(char * na):name(na){}
    		 void Print()
    		 {
     			cout<<name<<" Happy Birthday!"<<endl;
     		}
    	private:
    		const char * name;
    };
    int main()
    {
    	Happy_birthday qianshou("赵哲");
    	qianshou.Print();
    	return 0;
    }

    运行结果:

    静态数据成员

    其实常数据成员和静态数据成员完全是两码事,只不过一开始学习的时候容易混淆罢了。通过上面的解释,我们知道常数据成员类似常变量,是一种一经赋值就不可以改变的变量。

    它们最大的区别就是静态数据成员是可以被修改的,而且可以被任何一个对象修改,修改后的值,可以被所有的对象共享。

    静态数据成员是属于一个类的而不是某一个对象,它是为该类所定义的所有的对象所共有。该类所定义的对象都可以引用该静态成员,并且值都是一样的。

    静态数据成员的存储空间不同于普通的数据成员,它不属于类的任何一个对象,是独立于对象存储的,因此也不可以通过对象的this指针来访问

    并且,静态数据成员不可以用参数初始化表进行初始化操作,原因很简单,因为初始化表是在定义对象的时候进行的利用了this指针进行操作,所以不可以。

    静态数据成员的定义的方式:

    static int num;

    访问方式:

    可以通过类名直接访问:

    Test::s_num;

    也可以通过对象名访问:

    one.s_num;

    不过为了区别于其他的成员变量, 一般使用类名进行访问,因为静态数据成员不属于对象,以免使人误解。

    #include<iostream>
    using namespace std;
    class Test
    {
    	public:
    		Test(int n):c_num(n){};//只能用初始化表对常数据成员赋初值 
    		void show()
    		{
    			cout<<"c_num:"<<this->c_num<<endl;
    			cout<<"s_num:"<<s_num<<endl;
    		}
    		void change(int n)
    		{
    			s_num=n;	
    		} 
    		static int s_num;
    	private:
    		const  int c_num;
    };
    int Test::s_num=100;//在类体为对静态数据成员赋初值 
    int main()
    {
    	Test one(10);
    	one.show();
    	one.change(10000);//改变静态数据成员的值 
    	cout<<"one changeed:"<<one.s_num<<endl;	//使用对象名one间接访问静态数据成员 
    	cout<<"Test changeed:"<<Test::s_num<<endl;//使用类名直接访问静态数据成员
    	Test two(20);
    	cout<<"two changeed:"<<two.s_num<<endl; //使用对象名two间接访问静态数据成员 
    	two.change(99); 
    	cout<<"Test changeed:"<<Test::s_num<<endl;//使用类名直接访问静态数据成员 
    	return 0;
    }
    

    运行结果:

    分析:

    我们在程序中可以使用类名直接访问静态数据成员变量,就直接说明了它不属于任何一个对象的这个特点。

    我们在定义对象two的时候只对c_num进行了赋值,但是我们使用two.s_num进行输出的时候也是可以输出的,这也说明了这个数据成员确实可以被所有的对象进行引用,并且值都是相同的,因为它本身就不属于任何一个对象。

    好啦,大家晚安!


    展开全文
  • C++类的常数据成员成员函数

    千次阅读 2019-03-11 11:01:07
    //定义const为常数据成员 2、初始化 不能采用在构造函数中对常数据成员进行赋初值的方法,因为常数据成员是不能被赋值的。 构造函数只能用参数初始化列表对常数据成员进行初始化 Time ::Time (int h):hour(h...
  • C++静态数据成员定义及应用浅谈

    千次阅读 2012-08-24 14:23:10
    类体中的数据成员的声明前加上static...1.C++静态数据成员定义。  静态数据成员实际上是类域中的全局变量。所以,静态数据成员定义(初始化)不应该被放在头文件中。 其定义方式与全局变量相同。举例如下
  • 数据成员 python的类数据成员是不需要用self修饰的。例如 class my_class(object): value_list=[1,2] class1=my_class() print(my_class.value_list) print(class1.value_list) print(id(my_class.value_list...
  • 1.对象的数据成员不能被修改了,在定义的时候应该对其进行初始化 2.对象不能够调用普通成员函数——因为普通成员函数可能会修改对象的数据类型,这是不安全的。 3.对象可以调用静态成员函数,成员函数,...
  • 类的常数据成员必须进行初始化,而且只能通过构造函数的成员初始化列表的方式来进行。列表中对成员的初始化顺序,与它们在列表中的顺序无关,而与它们在类中的声明顺序有关。包含常数据成员的类不能使用默认构造函数...
  • 类静态数据成员定义及初始化

    千次阅读 2017-11-16 11:25:30
    类静态数据成员定义及初始化
  • 1.类是自定义的数据类型.类与应用程序不同,类的功能虽然独立,但...对象包含有member variables(成员变量)和member functions(成员函数). class Date{ int year, month, day; public: void set(int y,int m,int d);
  • C++ 常数据成员成员函数和对象

    千次阅读 多人点赞 2019-01-04 23:54:51
    首先给出一个例子简单理解const修饰数据变量的基本工作原理: #include &lt;stdio.h&gt; int main() { const int a = 250; int *ptr = (int *)&amp;a; *ptr = 360; printf("*ptr = %d\n&...
  • c++ 类数据成员定义、声明

    千次阅读 2014-03-08 16:54:27
    分配内存,调用构造函数时,隐式/显示的初始化各数据成员  2.进入构造函数后在构造函数中执行一般计算  1.类里面的任何成员变量在定义时是不能初始化的。  2.一般的数据成员可以在构造函数中初始化。  3....
  •   VS错误提示: 严重性 代码 说明 项目 文件行 禁止显示状态 ...错误 C2491 “SeaBreezeAPI::instance”: 不允许 dllimport 静态数据成员定义 VX700Pro E:\Oceanhood\Pro\seabreeze\SeaB...
  • c++中 类数据成员定义、声明总结

    千次阅读 2015-07-12 10:14:05
    1.分配内存,调用构造函数时,隐式/显示的初始化各数据成员 2.进入构造函数后在构造函数中执行一般计算  1.类里面的任何成员变量在定义时是不能初始化的。  2.一般的数据成员可以在构造函数中初始化。  3....
  • C++类中定义数据成员的类型的几种方式
  • VS2015错误提示解决方法---不允许 dllimport 静态数据成员定义
  • 哈哈,好久没有写过c++代码了,今天在一个c++类中定义了一个静态数据成员,结果在编译的时候总是不能通过,报出如下的一个问题: PartSpecialDemo error LNK2001: 无法解析的外部符号 "public: static int MyClass:...
  • 静态数据成员和静态数据成员函数

    千次阅读 多人点赞 2016-12-27 15:25:29
    c++中的static静态数据成员和静态成员函数应该是让大家比较头疼的东西,好像也是找工作公司面试中常常问到的东西。...1.静态数据成员怎么去定义? 在类中声明静态数据成员很简单,是以static关键字表明即可,
  • 定义字符型静态数据成员ServerName,保存其服务器名称;整型静态数据成员ClientNum,记录已定义的客户数量;定义静态函数ChangeServerName()改变服务器名称。 #include using namespace std; class Client { ...
  • 关于C++ 类中数据成员定义时初始化问题。

    千次阅读 多人点赞 2019-06-12 15:31:14
    很多人在习惯上在声明变量时就赋上初值,但对于c++类中的数据成员能否这样做呢? 显然是不行的,这是编译语法的规定。因为类就相当于一个数据的模板,是一种自定义组合的新数据类型,而不是一个变量。当程序声明一个...
  • LNK2001 无法解析的外部符号 "public: static struct ...如果确实需要使用__declspec(dllimport),要注意VC规定:数据、静态数据成员和函数可以声明,但不能定义为 dllimport。 转载于:https://www.cnblogs.com/...
  • 一般来说,可以定义为对象,在如下情况考虑把数据成员定义成指针,1)有多态的情况;会用到虚函数,基类指针2)可能和别的类共享,或者只是引用别的类里的某个对象,所以生命周期不是很确定(这个可...
  • 数据成员一般声明为private,以实现信息的隐蔽 成员函数一般声明为public,以提供外界使用的接口 构造函数一般声明为public,以便创建类的对象 创建一个类类型的对象时,编译器会自动使用一个构造函数来初始化该对象...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 821,156
精华内容 328,462
关键字:

常数据成员的定义