精华内容
下载资源
问答
  • 初始化列表写法
    2022-05-06 14:30:02
    // 1、声明时的写法
    class Point {
    
    private:
        int m_x{0};
        int m_y{0};
    };
    
    // 2、构造函数初始化列表中的写法
    class Point {
        Point() 
            : m_x{0}
            , m_y{0}
        {
    
        }
    private:
         int m_x;
         int m_y;
    };
    
    // 3、基于1、2的混合写法
    class Point {
        Point()
            : m_x{0}
        {
    
        }
    private:
        int m_x;
        int m_y{0};
    };
    

    有三点需要强调
    1、m_x{0} 为C++11版本后的统一初始化方式,类似m_x(0)/m_x = 0,相较于这两种,
    统一初始化方式可防止窄化转换,在容器构造时可转为initializer_list
    2、成员变量的初始化顺序严格跟声明顺序一致,即先m_x,后m_y,与初始化列表顺序无关
    3、声明时的初始化不会立即发生,也是在构造时触发,且顺序严格与声明顺序一致,
    即第3中情况,也是先初始化m_x,后m_y

    更多相关内容
  • C++构造函数之初始化列表

    千次阅读 2022-03-04 10:07:39
    C++构造函数的初始化列表详解

    C++构造函数之初始化列表

    构造函数可以说是对于C++每个类来说最重要的组成部分,之前也详细介绍过构造函数的相关知识,今天给构造函数进行补充,主要说明一下构造函数的初始值列表

    一、初始化列表的写法

    仍然以之前介绍构造函数时使用的学生类来举例说明:

    class Student{
    public:
        /*Student(int no, string name, int age){
            _no = no;
            _name = name;
            _age = age;//带参的构造函数
        }*/
        Student(int no, string name, int age)
        	:_no(no)
        	,_name(name)
        	,_age(age)
            {}//初始化列表
    private:
        int _no;
        string _name;
        int _age;
    };
    

    初始化列表出现了新的部分,以冒号开始,然后紧跟着的是以逗号为分隔符的数据成员列表,每个数据成员后面都有一个括号括号中的是该成员变量的初始值或表达式

    二、初始化列表的注意事项

    1. 每个成员变量在初始化列表中只能出现一次,即初始化只会初始化一次,但是在构造函数的函数体中可以进行多次赋值,初始化与赋值的区别有一篇博客写的不错,推荐阅读:

      https://www.cnblogs.com/lxy-xf/p/11049963.html

      初始化的含义是创建变量时赋予它一个初始值,而赋值则是把对象的当前值擦去,用一个新值来代替!(C++primer中的描述)

    2. 当类中包含了:①引用成员变量;②const成员变量;③自定义类型的成员变量(该类没有自己的默认构造函数默认构造函数详解见https://blog.csdn.net/weixin_45523353/article/details/123216917的第四部分)时,必须将这些成员放在初始化列表中进行初始化!

      class A{
      public:
          A(int a){
              _a = a;//有参构造,没有默认构造函数
          }
      private:
          int _a;
      };
      
      class Student{
      public:
          Student(int a, int age)
              :_aa(a)
              ,_age(age)
              ,_no(001)
              {}//必须在初始化列表中进行初始化
      private:
          A _aa;//自定义类型,且没有自己的默认构造函数
          int& _age;//引用
          const int _no//const的成员变量
      };
      
    3. 建议大家尽量使用初始化列表进行初始化,因为自定义类型的成员变量一定会先使用初始化列表初始化,下面这个例子可以帮助理解一下

      class A {
      private:
      	int _a;
      public:
      	A(int a = 0) {
      		_a = a;
      	}
      };
      
      class B {
      private:
      	A _aa;
      	int _b = 1;
      public:
      	B(int a, int b) {
      		_b = b;
      		_aa = A(a);//B这里并没有写出初始化列表
      	}
      };
      int main(){
      	B bb(20,15);//在这里打个断点
          return 0;
      }
      

      按照我们之前的理解,在创建B类型的变量bb时,使用的是B类型所提供的带参的构造函数,但是在监视窗口我们却发现,_b和_aa两个成员变量都已经被初始化了:

      image-20220303230435477

    尽管我们没有显式地写出初始化列表,这里也认为是有初始化列表的,其中的两个成员变量会使用默认初始化列表进行初始化,可以认为初始化列表就是对象的成员变量定义的地方。

    三、初始化的顺序

    非常重要的地方:在初始化列表中的顺序并非成员变量的初始化顺序!,成员变量的初始化顺序只与它在类中的声明次序相同

    class A{
        int a1;
        int a2;
    public:
        A(int a)
        :a2(a)
        ,a1(a2)
        {}//这里会报编译错误
    };
    

    上面的例子虽然看起在初始化列表中先用形参a初始化a2,再用a2初始化a1,但是成员变量的初始化顺序不能看它们在初始化列表中的顺序,而要看的是声明的顺序,a1先于a2声明,因此编译器会先去初始化a1,但此时a2并没初始化,因此a1也就无法初始化了。

    所以最好将初始化列表的各个成员顺序与类中的成员变量声明顺序保持一致,而且尽量不要用某个成员变量去初始化另一个成员变量!

    展开全文
  • 构造函数初始化列表

    千次阅读 2022-03-29 21:58:10
    构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表, 每个数据成员后面跟一个放在括号中的初始化式。 student(int m,int n):shengao(m),tizhong(n) { cout<<"初始化"<<endl;...

    目录

    一.构造函数初始化列表的基本形式 

    第一种: 

    第二种: 

    二.成员变量的初始化顺序只与成员变量在类中声明的顺序有关,与初始化列表中列出的变量的顺序无关


    一.构造函数初始化列表的基本形式 

    构造函数初始化列表以一个冒号开始,接着是以逗号分隔的数据成员列表,
    每个数据成员后面跟一个放在括号中的初始化式。

    第一种: 

    student(int m,int n):shengao(m),tizhong(n)
    	 {
    	 	cout<<"初始化"<<endl; 
    	 }

    第二种: 

    student():shengao(1.75),tizhong(100)
    {//student接收传进来的两个数,然后将两个数分别赋值给shengao,tizhong 
                          //之后private中的shengao和tizhong就分别有值了 
        cout<<"初始化"<<endl; 
     } 

    代码举例:对应第一种
    #include<iostream>
    using namespace std;
    class student
    {
    	private:
    		double shengao;
    		int tizhong;
    	public:
    		student(double m,int n):shengao(m),tizhong(n)
    		{//student接收传进来的两个数m和n,然后m赋值给shengao,n赋值给tizhong 
    		//之后private中的shengao和tizhong就分别有值了 
    			cout<<"初始化"<<endl; 
    		 } 
    		 void show()
    		 {
    		 	cout<<shengao<<endl<<tizhong;
    		 }
     } ;
    int main()
    {
    	student lisi(1.75,100);
    	lisi.show();
    	return 0;
     } 

    代码举例:对应第二种
    #include<iostream>
    using namespace std;
    class student
    {
    	private:
    		double shengao;
    		int tizhong;
    	public:
    		student():shengao(1.75),tizhong(100)
    		{//将两个数分别赋值给shengao,tizhong 
    		//之后private中的shengao和tizhong就分别有值了 
    			cout<<"初始化"<<endl; 
    		 } 
    		 void show()
    		 {
    		 	cout<<shengao<<endl<<tizhong;
    		 }
     } ;
    int main()
    {
    	student lisi;
    	lisi.show();
    	return 0;
     } 

    二.成员变量的初始化顺序只与成员变量在类中声明的顺序有关,与初始化列表中列出的变量的顺序无关

    //代码举例2:
    #include<iostream>
    using namespace std;
    class text
    {
    	private:
    		int math;
    		int English;
    	public:
    		text():English(90),math(English+10){}
    //因为先声明的math,但是当把English+10的值赋给math的时候还不知道English,
    //所以输出的math是个不确定的值(输出的math是个垃圾值)
    //math初始化完了之后,初始English,把90赋给English,最后输出90 
    		void print();//在此处声明print函数 
     } ;
     void text::print()//print函数是text类的一个对象,同时定义print函数 
     {
     	cout<<math<<endl<<English; 
      } 
    int main()
    {
    	text t;//定义t是text类的一个对象 
    	t.print();
    	return 0;
    }
     
    
    ​

    展开全文
  • Java的在还没有发现新写法之前时,我一直是这么初始化List跟Map: //初始化List List list = new ArrayList(); list.add("string1"); list.add("string2"); //some other list.add() code…… list.add(...
  • NULL 博文链接:https://elviszhao.iteye.com/blog/1699264
  • 主要介绍了Java中List与Map初始化的一些写法有需要的朋友可以参考一下
  • C++类和对象(下)——初始化列表、static成员和友元

    千次阅读 多人点赞 2021-03-08 09:23:18
    C++类和对象——初始化列表、static成员和友元一、再谈构造函数1.1 构造函数整体赋值1.2 初始化列表三级目录 关于C++类和对象的学习 C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针 C++...


    关于C++类和对象的学习
    C++类和对象(上)——类的基本概念、类的限定符及封装和类成员函数的this指针
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    一、再谈构造函数

    1.1 构造函数整体赋值

    在创建对象时,编译器通过调用构造函数,给对象中各个成员变量一个合适的初始值。例如我们之前创建的Date类

    class Date
    {
    public:
    
    	Date(int year = 1900, int month = 1, int day = 1)
    	{
    		_year = year;
    		_month = month;
    		_day = day;
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    

    虽然上述构造函数调用之后,对象中已经有了一个初始值,但是不能将其称作为类对象成员的初始化,构造函数体中的语句只能将其称作为赋初值,而不能称作初始化因为初始化只能初始化一次,而构造函数体内可以多次赋值

    1.2 初始化列表

    <1>为什么有初始化列表?

    对于我们定义的日期类,当类中出现以下成员时,如果只用构造函数则无法完成变量的初始化了,以下的成员变量需要在定义的时候就需要初始化

    • 引用成员变量
    • const成员变量
    • 自定义类型的成员变量

    在这里插入图片描述
    其次对于自定义的类成员变量,不使用初始化列表会调用多次构造函数
    在这里插入图片描述

    <2> 如何使用初始化列表

    初始化列表:以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式
    注意:每个成员变量在初始化列表中只能出现一次

    //1.2.2
    class Time
    {
    public:
    	Time(int hour = 1, int minute=1,int second = 1)
    		:_hour(hour)
    		,_minute(minute)
    		,_second(second)
    	{
    		cout << "Time(int hour = 1, int minute=1,int second = 1)" << endl;
    	}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	//初始化列表写法
    	Date(int year=1900, int month=1, int day=1,int hour=1,int minute=1,int second=1)
    		:_year(year)
    		,_month(month)
    		,_day(day)
    		,_n(10)
    		,_ref(day)
    		,_t(hour,minute,second)
    	{
    		cout << "Date(int year, int month, int day,int hour,int minute,int second)" << endl;
    
    	}
    
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	//定义的时候需要初始化
    	int& _ref;	//引用
    	const int _n; //const成员变量
    	Time _t;	//自定义类型的成员变量
    };
    
    void Test2()
    {
    	Date d1(2021,3,9,2,2,2);
    }
    

    结果在这里插入图片描述

    <3> 成员变量在类中声明次序就是其在初始化列表中的初始化顺序,与其在初始化列表中的先后次序无关

    如下代码的运行结果是什么?

    //1.2.3
    class A
    {
    public:
    	A(int a)
    		:_a1(a)
    		, _a2(_a1)
    	{}
    	void Print() {
    		cout << _a1 << " " << _a2 << endl;
    	}
    private:
    	int _a2;
    	int _a1;
    };
    
    void Test2()
    {
    	A aa(1);
    	aa.Print();
    }
    

    结果

    在这里插入图片描述

    1.3 explicit关键字

    <1> 匿名对象

    匿名对象顾名思义就是没有名字,其作用域只在一行中有效,例如下面的代码

    //1.3.1
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{
    		cout << "B(int b = 0)" << endl;
    	}
    
    	//析构函数
    	~B()
    	{
    		cout << "~B()" << endl;
    	}
    private:
    	int _b;
    };
    
    int main()
    {
    	B bb(10);	//生命周期在main函数域
    	B(2);	//匿名对象生命周期在这一行
    	return 0;
    }
    

    在这里插入图片描述
    在这里插入图片描述

    <2> 为什么有explicit关键字?

    对于c++来说,构造函数不仅可以构造与初始化对象,对于单个参数的构造函数,还具有类型转换的作用

    当我们定义一个类进行初始化时,如果我们采取下面这种定义方式,编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造

    //1.3.2
    class C 
    {
    public:
    	C(int c)
    		:_c(c)
    	{
    		cout << "C()" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    <3> 如何使用explicit关键字?

    用explicit修饰构造函数,将会禁止单参构造函数的隐式转换

    //1.3.3
    class C 
    {
    public:
    	explicit C(int c)
    		:_c(c)
    	{
    		cout << "explicit C(int c)" << endl;
    	}
    
    private:
    	int _c;
    };
    
    int main()
    {
    	C cc(2);
    	cc = 8;	//编译器会自动生成一个匿名对象,然后用匿名对象对cc对象进行拷贝构造
    	return 0;
    }
    

    在这里插入图片描述

    二、static成员

    2.1 概念

    声明为static的类成员称为类的静态成员,用static修饰的成员变量,称之为静态成员变量;用static修饰的成员函数,称之为静态成员函数。静态的成员变量一定要在类外进行初始化

    面试题:实现一个类,计算程序中创建出了多少个类对象?这个时候我们就可以使用static成员变量和static成员函数来实现

    //2.1 实现一个类,计算程序中创建出了多少个类对象。
    class A
    {
    public:
    	//构造函数
    	A()
    	{
    		++_scount;
    	}
    	//拷贝构造函数
    	A(const A& a)
    	{
    		++_scount;
    	}
    	
    	static int GetAcount()
    	{
    		return _scount;
    	}
    private:
    	static int _scount;
    };
    
    //初始化在类外
    int A::_scount = 0;
    
    void TestA()
    {
    	cout << A::GetAcount() << endl;
    	A aa;
    	A bb;
    	A cc(bb);
    	cout << A::GetAcount() << endl;
    }
    

    在这里插入图片描述

    2.2 特性

    <1> 静态成员为所有类对象所共享,不属于某个具体的实例

    <2> 静态成员变量必须在类外定义,定义时不添加static关键字

    在这里插入图片描述

    <3> 类静态成员即可用类名::静态成员或者对象.静态成员来访问

    在这里插入图片描述

    <4> 静态成员函数没有隐藏的this指针,不能访问任何非静态成员

    在这里插入图片描述

    <5>静态成员和类的普通成员一样,也有public、protected、private3种访问级别,也可以具有返回值

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

    不可以,因为静态成员函数没有隐藏的this指针

    Q2:非静态成员函数可以调用类的静态成员函数吗?

    可以,因为非静态成员函数含有this指针,指定了静态成员函数的类域
    在这里插入图片描述

    三、C++11的成员初始化新玩法

    3.1 为什么?

    对于C++98而言,类内自定义的内置类型,编译器会进行初始化,而其他内置类型不会,因此出现则会中初始化方法。
    具体查看这篇博客的2.2.7节内容
    C++类和对象(中)——类的6个默认成员函数(构造、析构、拷贝构造、赋值运算符重载)
    在这里插入图片描述

    3.2 怎么用?

    C++11支持非静态成员变量在声明时进行初始化赋值,但是要注意这里不是初始化,这里是给声明的成员变量缺省值

    //3.C++11的成员初始化新玩法
    class B
    {
    public:
    	B(int b = 0)
    		:_b(b)
    	{}
    	int _b;
    };
    class A
    {
    public:
    	void Print()
    	{
    		cout << a << endl;
    		cout << b._b << endl;
    		cout << p << endl;
    	}
    private:
    	// 非静态成员变量,可以在成员声明时给缺省值。
    	int a = 10;
    	B b = 20;
    	int* p = (int*)malloc(4);
    	//静态成员不可以
    	static int n;
    };
    int A::n = 10;
    
    int main()
    {
    	A a;
    	a.Print();
    	return 0;
    }
    

    在这里插入图片描述

    四、友元

    • 友元分为:友元函数友元类
    • 友元提供了一种突破封装的方式,有时提供了便利。但是友元会增加耦合度,破坏了封装,所以友元不宜多用

    4.1 友元函数

    问题:现在我们尝试去重载operator<<,然后发现我们没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象,才能正常使用。所以我们要将operator<<重载成全局函数。但是这样的话,又会导致类外没办法访问成员,那么这里就需要友元来解决。operator>>同理

    //4.1
    class Date
    {
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    int main()
    {
    	Date d(2017, 12, 24);
    	d << cout;
    	return 0;
    }
    

    在这里插入图片描述
    友元函数可以直接访问类的私有成员,它是定义在类外部的普通函数,不属于任何类,但需要在类的内部声明,声明时需要加friend关键字

    //4.1
    class Date
    {
    friend ostream& operator<<(ostream& _cout, const Date& d);
    friend istream& operator >> (istream& _cin, Date& d);
    
    public:
    	Date(int year, int month, int day)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    	ostream& operator<<(ostream& _cout)
    	{
    		_cout << _year << "-" << _month << "-" << _day;
    		return _cout;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    };
    
    ostream& operator<<(ostream& _cout, const Date& d)
    {
    	_cout << d._year << "-" << d._month << "-" << d._day << endl;
    	return _cout;
    }
    
    istream& operator >> (istream& _cin, Date& d)
    {
    	_cin >> d._year >> d._month >> d._day;
    
    	return _cin;
    }
    
    int main()
    {
    	Date d(2017, 12, 24);
    	cout<<d;
    	//Date d1;
    	cin >> d;
    	cout << d;
    	return 0;
    }
    

    在这里插入图片描述

    4.2 友元类

    友元类的所有成员函数都可以是另一个类的友元函数,都可以访问另一个类中的非公有成员。

    • 友元关系是单向的,不具有交换性。
      比如下面Time类和Date类,在Time类中声明Date类为其友元类,那么可以在Date类中直接访问Time类的私有成员变量,但想在Time类中访问Date类中私有的成员变量则不行。
    • 友元关系不能传递
      如果B是A的友元,C是B的友元,则不能说明C时A的友元。
    class Date; // 前置声明
    class Time
    {
    	friend class Date; // 声明日期类为时间类的友元类,则在日期类中就直接访问Time类中的私有成员变量
    public:
    	Time(int hour=0, int minute=0, int second=0)
    		: _hour(hour)
    		, _minute(minute)
    		, _second(second)
    	{}
    private:
    	int _hour;
    	int _minute;
    	int _second;
    };
    
    class Date
    {
    public:
    	Date(int year = 1900, int month = 1, int day = 1)
    		: _year(year)
    		, _month(month)
    		, _day(day)
    	{}
    
    	void SetTimeOfDate(int hour, int minute, int second)
    	{
    		// 直接访问时间类私有的成员变量
    		_t._hour = hour;
    		_t._minute = minute;
    		_t._second = second;
    	}
    private:
    	int _year;
    	int _month;
    	int _day;
    
    	Time _t;
    };
    

    五、内部类

    概念:如果一个类定义在另一个类的内部,这个内部类就叫做内部类。注意此时这个内部类是一个独立的类,它不属于外部类,更不能通过外部类的对象去调用内部类。外部类对内部类没有任何优越的访问权限。

    注意:内部类就是外部类的友元类。注意友元类的定义,内部类可以通过外部类的对象参数来访问外部类中的所有成员。但是外部类不是内部类的友元。

    特性:

    1. 内部类可以定义在外部类的public、protected、private都是可以的。
    2. 注意内部类可以直接访问外部类中的static、枚举成员,不需要外部类的对象/类名。
    3. sizeof(外部类)=外部类,和内部类没有任何关系
    class A
    {
    private:
    	static int k;
    	int h;
    public:
    	class B
    	{
    	public:
    		void foo(const A& a)
    		{
    			cout << k << endl;//OK
    			cout << a.h << endl;//OK
    		}
    	};
    };
    int A::k = 1;
    int main()
    {
    	A::B b;
    	b.foo(A());
    	return 0;
    }
    
    展开全文
  • 一、什么是初始化列表? 以一个冒号开始,接着是一个以逗号分隔的数据成员列表,每个"成员变量"后面跟一个放在括号中的初始值或表达式。 class Date { public: Date(int year, int month, int day) : _year...
  • 成员初始化列表

    2022-05-16 22:38:43
    如果我有一个类如下: class A { private: const int qsize; public: ...c++给出了答案:成员初始化列表。 从概念上说,在执行构造函数时,对象会在执行括号里的代码之前被创建,分配内存,然后
  • Jav 初始化 List 有什么好看的写法.pdf
  • Tensorflow 提供了7种不同的初始化函数: tf.constant_initializer(value) #将变量初始化为给定的常量,初始化一切所提供的值。 假设在卷积层中,设置偏执项b为0,则写法为: 1. bias_initializer=tf.constant_...
  • 数据成员赋值写法: class test { private: int re; int im; public: test(int r,int i) ...两者之间的区别:两者的得到的结果是一样的,但是在性能上存在着很大的差异,初始化列表明显比数据成员变量赋值要快
  • C++之列表初始化详解

    千次阅读 2022-04-11 16:40:04
    详细介绍列表初始化适用于哪些场景以及列表初始化所具有的优点,每个观点均有详细的代码验证,方便理解!
  • 初始化列表初始化数组

    千次阅读 2019-03-23 14:28:54
    学习了一下前缀树。 需要用到一个结构体保存两个指针,如下 struct Node ...能不能将初始化操作放在初始化列表中呢,如下 以上两种写法都有问题,突然想到,数组应该用大括号初始化啊 就酱。 ...
  • 在最近开发的一个Hybrid APP里,Android Webview初始化一个较重的vue页面竟然用了1200ms ~ 1400ms,这让我开始重视vue的初始化性能,并最终优化到200 ~ 300ms,这篇文章分享我的优化思路。 性能瓶颈在哪里? 先看...
  • 构造函数与初始化列表

    万次阅读 多人点赞 2018-08-01 18:17:33
    0.初始化与赋值的区别 意义上: 1)初始化:一个变量或者一个对象在产生的时候就赋予一个值,属于伴随性质 2)赋值:在一个变量或者一个对象在产生之后的任意时刻赋予一个值,属于任意性质 宏观代码上: 1)...
  • 既然构造函数初始化列表和构造函数体内赋值都可以对成员变量赋值,那么二者有何区别,是不是二者等效呢?  构造函数可以分两个阶段进行:(1)初始化阶段;(2)普通计算阶段。计算阶段也就是由函数体内...
  • } 采用初始化列表实现了对常量和引用的初始化。采用括号赋值的方法,括号赋值只能用在变量的初始化而不能用在定义之后的赋值。 凡是有引用类型的成员变量或者常量类型的变量的类,不能有缺省构造函数。默认构造函数...
  • c++类成员变量初始化详解

    千次阅读 2022-04-15 10:08:24
    1.类初始化顺序 当类初始化的时候,会调用其构造函数并进行初始化。当对象结束其生命周期,会调用析构函数进行资源回收。 注意类在调用资深构造函数之前,首先会调用其成员变量构造函数并进行初始化,再进入自身构造...
  • C/C++编程:列表初始化&列表赋值

    千次阅读 2021-03-21 19:35:25
    C++在初始化数组时,可以使用下面花括号加初始值的形式: int arr[] = {1, 2, 3}; 在C++中,如有下面这样的类: class Tester { public: Tester(int value):m_value(value * 2){} void print(){ cout <<...
  • C++_初始化列表

    2022-03-23 09:32:50
    1、传统的初始化 1.1、初始化 class Person{ public: int m_A; int m_B;... //传统初始化操作 ...2、初始化列表 ...用初始化列表初始化属性值; 2.2、语法 在形参列表后,加“:”开始写初始化列表,以“,”分
  • c++初始化列表和直接赋值的区别

    千次阅读 2018-08-13 23:48:18
    什么是构造函数初始化列表 定义两个构造函数: Sales_data(const std::string &amp;s): bookNo(s) {} Sales_data(const std::string &amp;s, unsigned n, double p):bookNo(s), units_sold(n), revenue...
  • 1.初始化加载方法一: <script type="text/javascript"> **$(functon(){ trace("初始化进入方法一") })** function trace(obj){ console.log(obj); } </script>
  • 如何优雅的初初始化Map

    千次阅读 2020-08-19 16:25:54
    Map的初始化 第一种: public void mapInit{ Map<String, String> myMap = new HashMap<String, String>(); myMap.put("a", "b"); } 第二种,匿名内部类初始化 HashMap<String, String > h = ...
  • 最近遇到一个新项目,涉及到多个页面需要时间初始化,想了半天终于想到一个超级简单的方法,可以作为公共部分使用,也可单独放在页面使用。 上代码: function getTime(){ var show=document.getElementById(...
  • JS文件的初始化的三种写法

    千次阅读 2017-07-25 14:14:07
    $(function(){…}); jQuery(function($) {…}); $(document).ready(function(){…})
  • hashmap初始化写法

    千次阅读 2018-03-13 21:44:19
    1、初始化1.5倍的写法 // 一位操作  Map&lt;String, String&gt; firstMap = new HashMap&lt;String, String&gt;(firstOrders.length + firstOrders.length&gt;&gt;1L);  for (int j = ...
  • 用参数初始化表对成员变量初始化 通过前面的学习,我们可以在类中定义带参数的构造函数。同时,在定义类对象的时候,给构造函数传递参数。通过给构造函数传递参数,可以给类的成员变量进行初始化。 C++还提供另一...
  • java中String初始化的两种方式

    千次阅读 2021-02-12 22:59:14
    转自:http://www.diybl.com/course/3_program/java/javajs/2007104/75886.html字符串可能是任何程序语言中都会出现的对象,java中创建并初始化一个String对象,最常见的方式有两种:String str=new String("XXX");...
  • 正常的是使用HTML语法DOM直接获取 var myChart = echarts.init(document.getElementById("main")); 使用jQuery的写法: var myChart1 = echarts.init($("#main")[0]); Done!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 252,176
精华内容 100,870
关键字:

初始化列表写法