精华内容
下载资源
问答
  • 1、类成员为const类型2、类成员为引用类型究其因const对象或引用只能初始化但是不能赋值。构造函数的函数体内只能赋值而不是初始化,因此初始化const对象或引用的唯一机会是构造函数函数体之前的初始化列表中。从无...
    1、类成员为const类型
    2、类成员为引用类型
    究其因
    const对象或引用只能初始化但是不能赋值。构造函数的函数体内只能赋值而不是初始化,因此初始化const对象或引用的唯一机会是构造函数函数体之前的初始化列表中。
    从无到有叫初始化,初始化(调用拷贝构造函数)创建了新对象;赋值(调用赋值操作符)没有创建新对象,而是对已有的对象赋值。 
    3、类成员为没有默认构造函数的类类型
    4、如果类存在继承关系,派生类必须在其初始化列表中调用基类的构造函数
    展开全文
  • C++静态成员变量的初始化

    万次阅读 2014-03-03 16:53:37
    需要注意的是:静态数据成员不能在类中初始化,一般在类外和main()函数之前初始化...2.静态成员不能在类定义里边初始化只能在class body外初始化。 3.静态成员仍然遵循public,private,protected访问准则。 4.静

    需要注意的是:静态数据成员不能在类中初始化,一般在类外和main()函数之前初始化,缺省时初始化为0。

    1.static成员的所有者是类本身,但是多个对象拥有一样的静态成员。从而在定义对象是不能通过构造函数对其进行初始化。

    2.静态成员不能在类定义里边初始化,只能在class body外初始化。
    3.静态成员仍然遵循public,private,protected访问准则。

    4.静态成员函数没有this指针,它不能返回非静态成员,因为除了对象会调用它外,类本身也可以调用

    静态成员属于全局变量,是所有实例化以后的对象所共享的,而成员的初始化你可以想象成向系统申请内存存储数据的过程,显然这种共有对象。不能在任何函数和局部作用域中初始化。

    class point{
    public:
    	point(){};
    //	...
    private:
    	static int x,y;
    };
    int point::x = 0;
    int point::y = 0;
    
    int main(){
    //	...
    }


    展开全文
  • 4种特殊的数据成员(常量数据成员,引用数据成员,类对象成员,静态成员) ...const数据成员只能通过成员初始化表进行初始化 #include #include using namespace std; class Point { private:  const int xP

    4种特殊的数据成员(常量数据成员,引用数据成员,类对象成员,静态成员)

    1const数据成员初始化

    在构造函数体内或拷贝构造函数体内初始化const数据成员都是非法的

    const数据成员只能通过成员初始化表进行初始化

    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    class Point
    {
    private:
         const int xPos;
          const int yPos;
    public:
    #if 0  //错误 const数据成员的初始化只能通过成员初始化表
     Point(int x,int y)
     {
      xPos=x;
      yPos=y;
     }
     Point(const Point &pt)
     {
      xPos=pt.xPos; //构造函数中初始化相当于赋值,而不是初始化

      yPos=pt.yPos; //const变量要求必须初始化不能赋值,所以必须在参数列表中
     }
    #endif
     Point(int x,int y):xPos(x),yPos(y)
     {
     }
     Point(const Point &pt)
      :xPos(pt.xPos),
      yPos(pt.yPos)
     {
     }
     void print()
     {
      cout<<"xPos"<<xPos<<"yPos"<<yPos<<endl;
     }
    };
    int main()
    {
     Point pt1(3,4);
     pt1.print();
     Point pt2(pt1);
     pt2.print();
     system("pause");
    }

    2引用初始化 (和const一样必须进行初始化 不能再构造函数体内)

    #include <iostream>
    using namespace std;
    class Point
    {
    private:
     int xPos;
     int yPos;
     int &ref1;
     double &ref2;
    public:
     Point(int x,int y,double &z)
      :ref1(xPos),
      ref2(z)
     {
      xPos=x;
      yPos=y;
     }
     Point(const Point &pt)
      :ref1(pt.ref1),
      ref2(pt.ref2)
     {
      xPos=pt.xPos;
      yPos=pt.yPos;
     }
     void print()
     {
      cout<<"xPos"<<xPos<<",yPos"<<yPos<<endl;
      cout<<",ref1:"<<ref1<<",ref2:"<<ref2<<endl;
     }
     void SetX(int x)
     {
      xPos=x;
     }
    };
    int main()
    {
     double outInt=5.0;
     Point pt(3,4,outInt);
     pt.print();
     Point p2(pt);
     p2.print();
     cout<<"修改p1中的x后"<<endl;
     pt.SetX(7);
     pt.print();
     p2.print();
     outInt=6;
     cout<<"outInt 变化后"<<endl;
     pt.print();
     p2.print();
     system("pause");
    }

    3类对象成员的初始化(只能在初始化列表初始)

    #include <iostream>
    using namespace std;
    class point
    {
    private:
     int xPos;
     int yPos;
    public:
     point(int x=0,int y=0)
     {
      cout<<"点的构造函数被执行"<<endl;
      xPos=x;
      yPos=y;
     }
     point(const point &pt)
     {
      cout<<"点的拷贝构造函数被执行"<<endl;
      xPos=pt.xPos;
      yPos=pt.yPos;
     }
     void print()
     {
      cout<<"("<<xPos<<","<<yPos<<")";
     }
    };
    class line
    {
    private:
     point pt1;
     point pt2;
    public:
     line(int x1,int y1,int x2,int y2)
      :pt1(x1,y1),
      pt2(x2,y2)
     {
      cout<<"线的构造函数被执行"<<endl;
     }
     line(const line &ll)
      :pt1(ll.pt1),
      pt2(ll.pt2)
     {
      cout<<"线的拷贝构造函数被执行"<<endl;
     }
     void draw()
     {
      pt1.print();
      cout<<"to";
      pt2.print();
      cout<<endl;
     }
    };

    int main()
    {
     line ll(1,2,3,4);
     ll.draw();
     line l2(ll);
     l2.draw();
     system("pause");
    }

    4static数据成员初始化

    静态数据成员的初始化必须在类申明之外进行,且不再包含static关键字

    #include <iostream>
    #include <stdlib.h>
    using namespace std;
    class computer
    {
    private:
     float price;
     static float total_price;
    public:
     computer(const float p)
     {
      price=p;
      total_price+=p;
     }
     ~computer()
     {
      total_price-=price;
     }
     void print()
     {
      cout<<"总价是:"<<total_price<<endl;
     }
    };
    float computer::total_price=0;
    int main()
    {
     computer comp1(7000);
     cout<<"购买电脑1后"<<endl;
     comp1.print();
     computer comp2(4999);
     cout<<"购买电脑2后"<<endl;
     comp2.print();
     comp2.~computer();
     cout<<"退掉电脑2后"<<endl;
     comp2.print();
     system("pause");
    }


    重点注意在初始列表中是初始化,而在构造函数和拷贝构造函数中是赋值不是初始化

    
    展开全文
  • 1 静态数据成员不能用参数初始化表对静态数据成员初始化 (1) 如果声明了类而未定义对象,则类的一般数据成员是不占内存空间的,只有在定义对象时,才为对象的数据成员分配空间。但是静态数据成员不属于某一个对象...

    1 静态数据成员不能用参数初始化表对静态数据成员初始化

    (1) 如果声明了类而未定义对象,则类的一般数据成员是不占内存空间的,只有在定义对象时,才为对象的数据成员分配空间。但是静态数据成员不属于某一个对象,在为对象所分配的空间中不包括静态数据成员所占的空间。静态数据成员是在所有对象之外单独开辟空间。只要在类中指定了静态数据成员,即使不定义对象,也为静态数据成员分配空间,它可以被引用。

    (2) 静态数据成员不随对象的建立而分配空间,也不随对象的撤销而释放(一般数据成员是在对象建立时分配空间,在对象撤销时释放)。静态数据成员是在程序编译时被分配空间的,至程序结束时才释放空间

    (3) 静态数据成员可以初始化,但只能在类体外进行初始化

    注意:静态数据成员不能用参数初始化表对其初始化。如在定义Box类中这样定义构造函数是错误的:Box(int h, int w, int len):height(h){}

    (4) 静态数据成员可以通过对象名引用,也可以通过类名引用。

                                     —《C++面向对象程序设计(第2版)》P104-P105

    分析:静态数据成员可以初始化,但只能在类体外初始化,并且不能用参数初始化表对其初始化。

    如: class Box

         {

            public:

               int volume();

           private:

               static int height;

               int width;

               int length

    };

     

    int Box::height = 10; //正确

    Box(inth, int w, int len):height(h){} //错误

     

    静态成员与对象无关,属于整个类,构造函数是构造某个具体的对象。创建一个对象的时候会用到初始化表,但是静态成员在对象创建之前就已经存在了,所以不需要再初始化表中初始化。

    展开全文
  • 成员初始化顺序

    2009-12-17 20:38:00
    编程时尽量将成员初始化放到初始化列表中,而不是构造函数体中,为什么要采取这样的策略呢,一方面,一些const只能初始化而不能被赋值,另一方面,在初始化列表中初始化成员比在构造函数体中通过赋值初始化成员...
  • 当将类的某个数据成员声明为static时,该静态数据成员只能被定义一次,而且要被同类的所有对象共享。各个对象都拥有类中每一个普通数据成员的副本,但静态数据成员只有一个实例存在,与定义了多少类对象无关。 静态...
  • 静态数据成员是属于类,而不属于那个具体对象的,所以任何对象都可以通过静态成员函数来访问静态数据成员,修改或者读取静态数据成员 上述比较好理解,其中提到了静态成员函数,静态成员函数只能访问静态成员,而不...
  • 2、C++中,const成员变量也不能在类定义处初始化只能通过构造函数初始化列表进行,并且必须有构造函数。 【const数据成员只在某个对象生存期内是常量,而对于整个类而言却是可变的。因为类可以创建多个对象,...
  • C++类中的静态数据成员初始化

    千次阅读 2016-05-16 14:49:24
    1、静态成员必须初始化,如果其是有公共访问属性的可以通过对象重新设置值,其最终值以最后一次设置的为准。 2、初始化方式只能是在类以外进行定义性说明 3、访问方式可以是对象.静态成员或ClassName::静态数据
  • JAVA之对象初始化过程详解及面试题

    千次阅读 2017-07-20 08:48:15
    一个朋友在JAVA面试题中遇到了对象初始化问题,发现自己只能靠敲代码,查看运行结果才能做出来。真是丢人呀。所以今天通过测试,在巩固一下基础,顺便写写笔记。 对象初始化流程如下: 初始化父类的静态成员...
  • java里初始化一个类的对象通过初始化快或者构造方法进行数据赋值。与其相关的执行代码有这么几种: 静态初始化块 初始化块 构造方法 静态初始化块 静态初始化块只在类加载时执行一次,同时静态初始化块...
  • C++中(const)常数据成员初始化

    千次阅读 2013-11-03 01:42:04
    常数据成员和常引用的初始化只能通过构造函数的成员初始化列表显示进行,而静态常数据成员仍保留静态成员的特征,在类外初始化。 例子:常数据成员初始化 #include /* run this program using the c
  • 总结: 1、const 数据成员不能在类内定义时初始化,在类外初始化也不行。通常通过构造函数初始化。 ...2、static 数据成员不能在类...类的静态数据成员在 类内只能声明,定义和初始化必须在类外 为什么静态成
  • 常对象 常成员函数是常对象唯一的对外接口。 常对象成员 常数据成员 只能通过构造函数初始化表对常数据成员进行初始化。 常成员函数 只能引用本类的数据成员,但不能修改。 ...
  • 从而在定义对象时不能通过构造函数对其进行初始化。 2.静态成员不能在类定义里边初始化只能在class body外初始化。 3.静态成员仍然遵循public,private,protected访问准则。 4.静态成员函数没有this指针,它不能...
  • 关于基类,派生类,访问权限,成员初始化列表的笔记 c++primer plus第6版中文版  首先,公有派生(继承)的方式,基类是一个公有基类。派生类对象包含基类对象。使用公有派生,基类的公有成员将成为...
  • 题:我看的书上写的对私有部分的访问可以是公共部分的成员函数,也可以是友员函数,那么可以直接对私有...2.静态成员不能在类定义里边初始化只能在class body外初始化。 3.静态成员仍然遵循public,private,prot
  • 对象成员: 在类声明时,在成员变量前面加上关键字const,即将成员声明为const;例const int a。 可以将其看做通过宏定义的常变量;...只能通过构造函数参数初始化表对常数据成员进行初始化。例Time::Time(int h)...
  • 12.2 C++常对象成员

    2021-06-10 16:06:34
    常数据成员的值是不能改变的,只能通过构造函数的参数初始化表对常数据成员进行初始化,不能采用在构造函数中对常数据成员赋初值的方法。 常对象的数据成员都是常数据成员,因此常对象的构造函数只能用参数初始化表...
  • 在列表初始化中才算是真正的初始化,而在函数体内的实际上是赋值操作,给成员变量分配内存是在列表初始化中完成的。 明白了这点就可以明白两点: 1.const变量的初始化只能在列表初始化中完成,因为在函数体内是赋值...
  • 理解初始化块和静态初始化块案例

    千次阅读 2014-02-26 18:54:04
    初始化块虽然也是Java类里的一种成员,但它没有名字,也就没有标识,因此无法通过类、对象来调用初始化块; 初始化只能在创建对象时自动执行而且在执行构造方法之前执行。 静态初始化块  如果定义初始化块时...
  • Java类 初始化

    2019-09-30 08:01:19
    java里初始化一个类的对象通过初始化快或者构造方法进行数据赋值。与其相关的执行代码有这么几种: 静态初始化块 初始化块 构造方法 静态初始化块 静态初始化块只在类加载时执行一次,同时静态初始化块...
  • 对象成员

    2017-05-14 20:41:00
    //注意:定义常数据成员就必须对他进行初始化,并且只能通过构造函数的初始化表对常数据成员进行初始化 class Time { private: const int hour; //声明hour为常数据成员 int min; int sec; public: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 615
精华内容 246
关键字:

对象成员只能通过初始化