精华内容
下载资源
问答
  • 我们明确在初始化一个派生对象时,会先调用基类的构造函数,然后再调用派生的构造函数;在回收资源的时候,先调用派生的析构函数,再调用基类的析构函数。 我们在初始化一个派生的对象时,如何去初始化一个...

    我们明确在初始化一个派生类对象时,会先调用基类的构造函数,然后再调用派生类的构造函数;在回收资源的时候,先调用派生类的析构函数,再调用基类的析构函数。

    我们在初始化一个派生类的对象时,如何去初始化一个基类的成员变量呢?这里的初始化是指将基类成员变量初始化成我们指定的参数,也就是说想要在初始化派生类对象时将派生类和基类的成员变量的值都传进去。

    #include<iostream>
    
    using namespace std;
    
    class Date
    {
    public:
    	Date(int year=0 , int month=0 , int day=0)
    		:_year(year)
    		, _month(month)
    		, _day(day)
    	{
    		cout << "基类构造函数调用" << endl;
    	}
    	Date(const Date& date)
    	{
    		_year = date._year;
    		_month = date._month;
    		_day = date._day;
    		cout << "基类拷贝构造函数调用" << endl;
    	}
    	~Date()
    	{
    		cout << "基类析构函数调用" << endl;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    class DateSon:public Date
    {
    public:
    	DateSon(int hour = 0, int min = 0, int sec = 0, int year = 0, int month = 0, int day = 0)
    		:_hour(hour)
    		, _min(min)
    		, _sec(sec)
    		,Date(year,month,day)
    	{
    		cout << "派生类构造函数调用" << endl;
    	}
    	DateSon(const DateSon& date)
    		:Date(date)
    	{
    		_hour = date._hour;
    		_min = date._min;
    		_sec = date._sec;
    		cout << "派生类拷贝构造函数调用" << endl;
    	}
    	
    	~DateSon()
    	{
    		cout << "派生类析构函数调用" << endl;
    	}
    private:
    	int _hour;
    	int _min;
    	int _sec;
    };
    
    int main()
    {
    	DateSon date1(1,2,3,4,5,6);
    	DateSon date2(date1);
    	return 0;
    }

    解决方法就是需要在派生类中显式的调用基类的构造函数和拷贝构造函数

    展开全文
  • 错误: ISO C++ 不允许在类内初始化非常量静态成员  今天开始学C++ primer,在牵扯到Sales_item.h头文件时,出现了一些问题(和C++11新特性相关),当前的编译器版本是gcc/g++ 4.6.3,所以需要升级。可以利用...
    错误: ISO C++ 不允许在类内初始化非常量静态成员

         今天开始学C++ primer,在牵扯到Sales_item.h头文件时,出现了一些问题(和C++11新特性相关),当前的编译器版本是gcc/g++ 4.6.3,所以需要升级。可以利用PPA升级到4.8.1,如下:

    sudo add-apt-repository ppa:ubuntu-toolchain-r/test

    sudo apt-get update; sudo apt-get install gcc-4.8 g++-4.8

    sudo update-alternatives --remove-all gcc 
    sudo update-alternatives --remove-all g++

    sudo update-alternatives --install /usr/bin/gcc gcc /usr/bin/gcc-4.8 20
    sudo update-alternatives --install /usr/bin/g++ g++ /usr/bin/g++-4.8 20

    sudo update-alternatives --config gcc
    sudo update-alternatives --config g++

    g++ --version

    展开全文
  • C++11新特性(8)- 类内初始化

    千次阅读 2018-04-11 20:33:49
    重复的初始化代码考察下面的代码:enum LineStyle{ lsSolid, lsDash, lsDot, };class Rect{public: Rect() :left{0}, top{0}, right{0}, bottom{} ,style{lsSolid} { } Rect(int l, int t, int ...

    重复的初始化代码


    考察下面的代码:


    enum LineStyle{

       lsSolid,

       lsDash,

       lsDot,    

    };

    class Rect

    {

    public:

       Rect()

           :left{0}, top{0}, right{0}, bottom{}

           ,style{lsSolid}

       {    

        }

       Rect(int l, int t, int r, int b)

           :left{l}, top{t}, right{r}, bottom{b}

           ,style{lsSolid}

       {

       }

       Rect(int l, int t, int r, int b, LineStyle ls)

           :left{l}, top{t}, right{r}, bottom{b}

           ,style{ls} 

       {

       }

    private:

       int top;

       int left;

       int right;

       int bottom;

       LineStyle style;    

    };


    这算是正常不过的代码,但是有一个不算是问题的问题:初期值为缺省值的数据包成员也需要在构造函数里指定,感觉不好。


    类内初始化


    C++11中引入了类内初始化器,以减少构造函数和初始化代码的数量。说起来挺玄,其实就是下面代码中背景加亮的部分。


    class Rect

    {

    public:

       Rect(int l, int t, int r, int b)

           :left{l}, top{t}, right{r}, bottom{b}

       {  

       }

       Rect(int l, int t, int r, int b, LineStyle ls)

           :left{l}, top{t}, right{r}, bottom{b}

           ,style{ls}

       {

       }

    private:

       int top{0};

       int left{0};

       int right{0};

       int bottom{0};

       LineStyle style{lsSolid};    

    };


    类内初始化之后,构造函数只需要负责和缺省值不同的部分就好,代码精炼很多了。


    作者观点


    有人说,改善都是懒人发起的,作者认为:有一部改善应该是强迫症发起的。


    觉得本文有帮助?请分享给更多人。
    阅读更多更新文章,请扫描下面二维码,关注微信公众号【面向对象思考】

    展开全文
  • Java初始化、变量的初始化

    万次阅读 2018-06-02 15:21:23
    Java初始化、变量的初始化知识点Java常量, final 修饰,值被设定后不能再被修改静态变量里, static 修饰,顾名思义,无须创建对象,便可在内存中申请一个存储空间进行存储成员变量, 也称实例变量,它随着当前...

    Java类的初始化、变量的初始化


    知识点

    • Java常量,   final 修饰,值被设定后不能再被修改
    • 静态变量里,  static 修饰,顾名思义,无须创建对象,便可在内存中申请一个存储空间进行存储
    • 成员变量,  也称实例变量,它随着当前对象的建立而建立,随着对象的销毁而销毁,存在于对象所在的堆内存
    • 构造器,创建class对象时执行
    • 静态初始化块  ,执行优先级高于非静态的初始化块,它会在对象装载到 jvm的时候执行一次,执行完成便销毁,只能初始化 static 修饰的变量
    • 非静态初始化块,执行的时候如果有静态初始化块,先执行静态初始化块再执行非静态初始化块,在每个对象生成时都会被执行一次,它可以初始化类的实例变量。但它会在构造函数执行之前被执行

    类的初始化顺序

    Java中类初始化顺序,依次是(静态变量、静态初始化块)>(变量、初始化块)>构造器。。


    Java变量的初始化问题探究


    对于java的变量,我们知道有成员变量局部变量。

    关于他们的初始化,基本上所有书上都会写。成员变量,java会帮助你初始化,局部变量,则需要程序员自己初始化。

    对于类的成员变量。不管程序有没有显示的初始化,Java  虚拟机都会先自动给它初始化为默认值。

    规则为:

    1、整数类型(byte、short、int、long)的基本类型变量的默认值为0。

    2、单精度浮点型(float)的基本类型变量的默认值为0.0f。

    3、双精度浮点型(double)的基本类型变量的默认值为0.0d。

    4、字符型(char)的基本类型变量的默认为 “/u0000”。

    5、布尔性的基本类型变量的默认值为 false

    6、引用类型的变量是默认值为 null。

    7、数组引用类型的变量的默认值为 null。春关键数组变量的实例后,如果没有没有显示的为每个元素赋值,Java 就会把该数组的所有元素初始化为其相应类型的默认值。

    局部变量初始化

    局部变量声明以后,Java 虚拟机不会自动的为它初始化为默认值。因此对于局部变量,必须先经过显示的初始化,才能使用它。

    如果编译器确认一个局部变量在使用之前可能没有被初始化,编译器将报错。

    那么,加了修饰的java成员变量是如何初始化的呢在何时?在程序中的什么位置?

    下面看个小程序。

    [java]  view plain  copy
    1. public class TestC {  
    2.     /* 
    3.      * 定义成员变量 
    4.      * 尾数为1表示定义时进行初始化赋值 
    5.      * 尾数为2表示在代码块中进行初始化赋值 
    6.      * 尾数为3表示在构造函数中进行初始化赋值 
    7.      * 尾数为4表示在静态代码块中进行初始化赋值 
    8.      * 尾数为5表示不初始化赋值 
    9.      */  
    10.     /* 
    11.      * 普通成员变量  
    12.      */  
    13.     int field_a1 = 5;  
    14.     int field_a2;  
    15.     int field_a3;  
    16.     //报错:不能再静态代码块中使用非静态变量。 Cannot make a static reference to the non-static field field_a4  
    17.     //int field_a4;  
    18.     int field_a5;  
    19.     /* 
    20.      * final 成员变量 
    21.      */  
    22.     final int  field_b1 = 5;  
    23.     final int  field_b2;  
    24.     final int  field_b3;  
    25.     //报错:不能再静态代码块中使用非静态变量。Cannot make a static reference to the non-static field field_b4  
    26.     //final int  field_b4;  
    27.     //报错:未初始化 。The blank final field field_b5 may not have been initialized  
    28.     //final int  field_b5;  
    29.     /* 
    30.      * static成员变量 
    31.      */  
    32.     static int field_c1 = 5;  
    33.     static int field_c2;  
    34.     static int field_c3;  
    35.     static int field_c4;  
    36.     static int field_c5;  
    37.     /* 
    38.      * static final 成员变量 
    39.      */  
    40.     static final int field_d1 = 5;  
    41.     //报错:未初始化 。The blank final field field_d2 may not have been initialized  
    42.     //static final int field_d2;  
    43.     //报错:未初始化 。The blank final field field_d3 may not have been initialized  
    44.     //static final int field_d3;  
    45.     static final int field_d4;  
    46.     //报错:未初始化 。The blank final field field_d5 may not have been initialized  
    47.     //static final int field_d5;  
    48.       
    49.     //代码块  
    50.     {  
    51.           
    52.         field_a2 = 5;  
    53.         field_b2 = 5;  
    54.         field_c2 = 5;  
    55.         //field_d2 = 5;  
    56.     }  
    57.       
    58.     //静态代码块  
    59.     static{  
    60.         //field_a4 = 5;  
    61.         //field_b4 = 5;  
    62.         field_c4 = 5;  
    63.         field_d4 = 5;  
    64.     }  
    65.       
    66.     //构造函数  
    67.     public TestC(){  
    68.         field_a3 = 5;  
    69.         field_b3 = 5;  
    70.         field_c3 = 5;  
    71.         //field_d3 = 5;  
    72.           
    73.     }  
    74. }  

    然后我们对这个程序生成的.class文件进行反编译,看看他是如何运行的。

    下面是TestC.jad文件。反编译文件

    [java]  view plain  copy
    1. public class TestC  
    2. {  
    3.   
    4.     public TestC()  
    5.     {  
    6.         field_a1 = 5;  
    7.         field_a2 = 5;  
    8.         field_c2 = 5;  
    9.         field_a3 = 5;  
    10.         field_c3 = 5;  
    11.     }  
    12.   
    13.     int field_a1;  
    14.     int field_a2;  
    15.     int field_a3;  
    16.     int field_a5;  
    17.     final int field_b1 = 5;  
    18.     final int field_b2 = 5;  
    19.     final int field_b3 = 5;  
    20.     static int field_c1 = 5;  
    21.     static int field_c2;  
    22.     static int field_c3;  
    23.     static int field_c4 = 5;  
    24.     static int field_c5;  
    25.     static final int field_d1 = 5;  
    26.     static final int field_d4 = 5;  
    27.   
    28. }  

    看到这里我们就很有清晰的思路了。

    对于不加修饰的普通成员变量,无论我们在什么地方对其进行初始化赋值,系统都会默认在构造函数中进行赋值。

    对于final变量,无论我们在什么地方进行赋值,系统会默认final变量是在类中进行初始化

    对于static,系统会根据我们的需求,而在不同位置进行初始化。


    通过报错,我们可以发现。

    final变量必须进行初始化。否则就会报编译错误。The blank final field field_d5 may not have been initialized

    static成员变量的初始化发生在类被类加载器(classLoader)加载的时候系统会对没有初始化的静态成员变量在静态区进行默认赋值。

    普通成员变量的初始化发生在JVM为类生成实例开辟空间的时候进行默认初始化赋值


    参考博文:https://blog.csdn.net/wlcw16/article/details/8506846


    展开全文
  • 在C++中,的静态成员(static member)必须在类内声明,在初始化,像下面这样。 class A { private: static int count ; // 类内声明 }; int A::count = 0 ; // 初始化,不必再加static关键字 ...
  • 深入理解Java对象的创建过程:初始化与实例化

    万次阅读 多人点赞 2017-05-18 14:17:45
    类初始化过程中或初始化完毕后,根据具体情况才会去对类进行实例化。本文试图对JVM执行类初始化和实例化的过程做一个详细深入地介绍,以便从Java虚拟机的角度清晰解剖一个Java对象的创建过程。
  • 为什么静态成员必须在初始化

    千次阅读 2013-08-07 23:10:34
    为什么静态成员不能在类内初始化 在C++中,的静态成员(static member)必须在类内声明,在初始化,像下面这样。 class A { private: static int count ; // 类内声明 }; int A::count = 0 ; // 初始...
  • JAVA笔记-初始化及对象的初始化

    千次阅读 2016-06-26 13:19:24
    初始化及对象初始化 初学Java,觉得初始化与对象的初始化这一块真的特别重要,翻了很多大神前辈的整理资料,还是有些懵懂,决定将资料整理下,也希望对后来的初学者有些许帮助。 上图为的生命周期 ...
  • 在C++98标准里,只有static const声明的整型成员能在内部初始化,并且初始化值必须是常量表达式。这些限制确保了初始化操作可以在编译时期进行。例如: int var = 7; class X { static const int m1 = 7; // ...
  • C++指针初始化

    千次阅读 2017-12-29 14:22:17
    初始化为NULL的指针可以安全的调用不涉及成员变量的成员函数而不出错,但是如果成员函数中调用了成员变量则会出错,既然赋值为NULL的情况都可以使用,那么自然不初始化指针同样满足这情况。...
  • Java 类初始化

    千次阅读 2018-09-09 18:02:02
    Java 类初始化介绍 java语言在使用过程中最先开始就是初始化,在工作中如果遇到什么问题需 要定位往往到最后也可能是初始化的问题,因此掌握初始化的顺序很重要。 根据java 语言特性,本人针对初始化中常遇到的...
  • static成员必须在初始化

    千次阅读 2013-08-26 13:00:57
    在C++中,的静态成员(static member)必须在类内声明,在初始化,像下面这样 class A { private: static int count ; // 类内声明 }; int A::count = 0 ; // 初始化,不必再加static关键字 为什么
  • /*父类对象*/ public class Father{ private int i = test(); private static int j = method(); static{ System.out.print("(1)"); } Father(){ System.out.print("(2)"); } { System.out.print("(3...}
  • 构造函数初始化时必须... (常量成员)需要初始化const修饰的成员 3. (引用)需要初始化引用成员数据class A { ... private: int a; }; class C{ C(int b); }; class B : public A { ... private: int a;...
  • C++编程语言中创建的对象(初始化)的方法

    万次阅读 多人点赞 2018-08-07 21:03:55
    本文主要介绍在 C++ 编程语言中,创建的对象(初始化)的两种方法,这两种方法分别为:“直接使用类名创建对象”和“使用 new 关键字创建对象”。 1 概述 “直接使用类名创建对象”和“使用 new 关键字创建...
  • @java的加载顺序 Java的加载顺序 父类静态代变量、 父类静态代码块、 子类静态变量、 子类静态代码块、 父类非静态变量(父类实例成员变量)、 父类构造函数、 子类非静态变量(子类实例成员变量)、 子类构造...
  • 为什么static成员必须在初始化

    千次阅读 2015-10-25 22:41:56
    为什么静态成员不能在类内初始化在C++中,的静态成员(static member)必须在类内声明,在初始化,像下面这样。class A { private: static int count ; // 类内声明 };int A::count = 0 ; // 初始化,...
  • C++基础 内置类型和类型的默认初始化和值初始化写在前面的话如果定义变量时候没有指定初值,则变量被默认初始化。 但是默认初始化还有另外一个含义,在定义内置类型时由于定义变量的位置不同,有可能会不发生初始...
  • 类初始化

    千次阅读 2016-10-25 15:29:22
    主动引用类初始化是类加载过程的最后一个阶段,到初始化阶段,才真正开始执行类中的Java程序代码。虚拟机规范严格规定了有且只有四种情况必须立即对类进行初始化: 遇到new、getstatic、putstatic、invokestatic这四...
  • C++成员的初始化

    千次阅读 2016-03-29 13:00:03
    C++成员的初始化C++包括的...静态成员不能在类内初始化在C++中,的静态成员(static member)必须在类内声明,在初始化,像下面这样。class A { private: static int count ; // 类内声明 }; int A::cou

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,191,950
精华内容 876,780
关键字:

类内初始化