精华内容
下载资源
问答
  • privateintnumber;privateinttypeIndex;privateMyDatedate;privatebooleanhasFinished;privateCompetitor[]competitors;privateintnumberOfCompetitors;...怎么样才能给这个数组附上competitor的值? 展开

    privateintnumber;privateinttypeIndex;privateMyDatedate;privatebooleanhasFinished;privateCompetitor[]competitors;privateintnumberOfCompetitors;publicvoidCompetitor(Stringn...

    private int number;

    private int typeIndex;

    private MyDate date;

    private boolean hasFinished;

    private Competitor[] competitors;

    private int numberOfCompetitors;

    public void Competitor(String name, int number, int typeIndex, int age){}

    public Race(int number, int typeIndex, MyDate date) {

    this.number=number;

    this.typeIndex=typeIndex;

    this.date=date;

    this.hasFinished=false;

    this.competitors=new Competitor[MAX_COMPETITORS-1];

    this.numberOfCompetitors=0;

    }

    public boolean addCompetitor(Competitor competitor) {

    if(numberOfCompetitors

    competitors[numberOfCompetitors]=competitor;

    numberOfCompetitors++;

    System.out.println(competitors[numberOfCompetitors]);

    return true;

    }

    return false;

    }

    我这个数组是不是已经定义过了?那在addCompetitor方法里应该是可以调用Competitor class的吧?为什么 System.out.println(competitors[numberOfCompetitors]);显示的全都是null呢?怎么样才能给这个数组附上competitor的值?

    展开

    展开全文
  • ![图片说明](https://img-ask.csdn.net/upload/201605/20/1463753677_81314.png)![图片说明](https://img-ask.csdn.net/upload/201605/20/1463753694_705350.png)![图片说明]...
  • 带参构造函数的类对象数组初始化

    千次阅读 2015-01-07 18:47:01
    带参构造函数的类对象数组初始化

    今天同学问我个问题:有一个带参构造函数的类,如何初始化其对象数组?仔细想了想,应该不难额,比如:

    #include <iostream>  
    using namespace  std;  
    
    class A {
    public:
    	A(int a)
    	{cout << "construct" << a << endl;}
    };
    
    int main()  
    {  
    	A arr[] = {A(1), A(2), A(3), A(4), A(5)};
    	return 0;  
    }  
    但是问题来了,如果数组长度太大怎么办?想了一下,目前所知道的有两种比较好的办法:

    (1)使用STL容器vector来代替静态数组:

    #include <iostream> 
    #include <vector> 
    
    class A {
    public:
    	A(int a)
    	{cout << "construct" << a << endl;}
    };
    
    int main()  
    {  
    	vector<A> va;
    	for(int i = 0; i < 50; i++)
    		va.push_back(A(i));
    	return 0;  
    }  
    但这里每次push_back时除了调用A的构造函数外还会调用A的拷贝构造函数,而且在数组大小动态增长的过程中,由于动态申请内存可能导致数据的搬移也会再次调用A的拷贝构造函数,这样效率比较低下。

    (2)利用operator new + 动态内存处理:

    #include <iostream> 
    using namespace  std;  
    
    class A {
    public:
    	A(int a)
    	{cout << "construct" << a << endl;}
    	~A()
    	{cout << "~A()\n";}
    };
    
    int main()  
    {  
    	A *pa = reinterpret_cast<A *>(::operator new(sizeof(A) * 50));
    	for(int i = 0; i < 50; i++)
    		new(&pa[i]) A(i);
    	for(int i = 0; i < 50; i++)
    		pa[i].~A();
    	delete pa;
    	return 0;  
    }  
    
    不过,这里要注意自行调用A的析构函数,而且这里申请的内存虽然用于数组,但operator new仅申请内存,并未存放数组长度等信息,不能由delete []的形式释放。



    展开全文
  • 1,数组是由多个成员组成的有序...2,数组初始化 构造函数方法 var arr=new Array undefined arr [] var arr=new Array() undefined arr [] 传入一个参数表示初始化的数组的个数 成员都初始化为 undefined var arr

    1,数组是由多个成员组成的有序的集合

    数组的成员类型不一定要一致

    数组的成员是有序的

    数组的成员是有个数的

    索引从0开始

    2,数组初始化

    构造函数方法

    var arr=new Array
    undefined
    arr
    []
    var arr=new Array()
    undefined
    arr
    []

    传入一个参数表示初始化的数组的个数 成员都初始化为 undefined

    var arr=new Array(10)
    undefined
    arr
    (10) [empty × 10]
    arr[0]
    undefined

    new 关键字可以省略

    var arr=Array(1,2,3)
    undefined
    arr
    (3) [1, 2, 3]
    也可以直接指定数组的成员


    字面量方法 

    无法指定初始化的数组的成员的个数

    可以初始化成员


    var arr=[]
    undefined
    arr
    []
    var arr=[1,2,3]
    undefined
    arr
    (3) [1, 2, 3]
    3,成员的访问

    arr[n-1]

    可以访问第 n 个成员

    给数组的不存在的成员进行赋值的时候 会直接创建这个成员 如果这个成员的前面有不存在的成员的话 会将这些成员补全 并初始化为 undefined

    var arr=[]
    undefined
    arr[9]=10
    10
    arr
    (10) [empty × 9, 10]
    arr.length
    10
    arr[8]
    undefined

    4,数组的检查

    数组不属于基本数据类型

    用typeof 不能确定是否是数组还是对象


    var arr=[1,2,3]
    undefined
    typeof arr
    "object"
    var obj={}
    undefined
    typeof obj
    "object"

    有两种方法

    instanceof 关键字

    var arr=[];
    var obj={};
    
    undefined
    arr instanceof Array;
    true
    obj instanceof Array;
    false

    Array的静态方法

    Array.isArray()

    var arr=[];
    undefined
    var obj={};
    undefined
    Array.isArray(arr);
    true
    Array.isArray(obj);
    false







    展开全文
  • 起初我的理解是该语句的初始化是:SArray[0](“big”),也就是用一个字符数组初始化一个class MyString,但是我已经写了这个构造函数啊,不应该出错啊。然后在一步猜测,这个初始化可能是SArray[0](Mystrin...

    今天再编写C++的作业时,又遇到一个问题,MyString SArray[4] = {“big”,“me”,“about”,“take”};这个的初始化始终出错。起初我的理解是该语句的初始化是:SArray[0](“big”),也就是用一个字符数组来初始化一个class MyString,但是我已经写了这个构造函数啊,不应该出错啊。然后在一步猜测,这个初始化可能是SArray[0](Mystring & str),但是也不对啊,我也写了复制构造函数啊,然后百思不得其解,结果一下午又耗在这上了,唉,哭笑不得。
    终于在3小时候发现了错误,原来我的复制构造函数写成了Mystring( Mystring & str),正确应该是Mystring(const Mystring & str),因为这是一个const型实参,因此形参必须是const型,否则传参数是要失败的,因为const型的变量不能够给变量来赋值(如果赋值了,变量一边,const也变了,所以干脆编译时就禁止)。因为这一个小错误,浪费了3小时,唉,以后一定要注意,赋值构造函数的参数设成const型,可以确保正确。
    但是以上题目我依旧有一点不大明白,也就是说为什么类数组初始化是用Mystring类来初始化的,而不是用字符数组“big”这一些来初始化的。希望继续学习后能解决此迷惑,或还请高手指点一二。

    以下附上我的代码:

    #include <cstdlib>
    #include <iostream>
    using namespace std;
    int strlen(const char * s) 
    {	int i = 0;
    	for(; s[i]; ++i);
    	return i;
    }
    void strcpy(char * d,const char * s)
    {
    	int i = 0;
    	for( i = 0; s[i]; ++i)
    		d[i] = s[i];
    	d[i] = 0;
    		
    }
    int strcmp(const char * s1,const char * s2)
    {
    	for(int i = 0; s1[i] && s2[i] ; ++i) {
    		if( s1[i] < s2[i] )
    			return -1;
    		else if( s1[i] > s2[i])
    			return 1;
    	}
    	return 0;
    }
    void strcat(char * d,const char * s)   //将字符串s拼接到字符串d的后面
    {
    	int len = strlen(d);
    	strcpy(d+len,s);
    }
    
    
    class MyString
    {
    // your code
    		char * p;
    public:
    	MyString(const char * s) {         //constructor function with a string
    		if( s) {
    			p = new char[strlen(s) + 1];
    			strcpy(p,s);
    		}
    		else
    			p = NULL;
    
    	}
    
    
    	/*MyString(char a[]) {         //constructor function with a *char
    		if(a) {
    			p = new char[strlen(a) + 1];
    			strcpy(p,a);
    		}
    		else
    			p = NULL;
    
    	}*/
    
    
    	MyString (const MyString & s)    //copy constructor function
    	{
    		if(s.p){
    			p = new char[strlen(s.p+1)];
    			strcpy(p,s.p); 
    		}
    		else 
    			p = NULL;
    	}
    
    
    	MyString(){
    		this->p = new char[1];
    		*(this->p) = 0;
    	}
    
    
    	~MyString() { if(p) delete [] p; }
    
    
    	void Copy( const char *s)
    	{
    		if (s){
    			p = new char[strlen(s) + 1];
    			strcpy(p,s);
    		}
    		else
    			p = NULL;
    	}
    
    
    	MyString & operator= (const char*s)          //factor is the pointer
    	{
    		if (p)
    			delete []p;
    		if(s){
    			p = new char[strlen(s)+1];
    			strcpy(p,s);
    		}
    		else
    			p = NULL;
    		return *this;
    	}
    
    
    	MyString & operator= (const MyString & s)       //factor is the class MyString
    	{
    		if (p == s.p){
    			return *this;
    		}
    		if(p)
    			delete []p;
    		if (s.p){
    			p = new char [strlen(s.p)+1];
    			strcpy(p,s.p);
    		}
    		else
    			p = NULL;
    		return *this;
    	}
    
    
    	char& operator[] (int n)
    	{
    		return this->p[n];
    	}
    
    
    
    	MyString operator+ (MyString s)   //reload the operator +
    	{
    		MyString temp;
    		int length1 = strlen(this->p);
    		int length2 = strlen(s.p);
    		temp.p = new char[length1 + length2 + 1];
    		strcpy(temp.p,this->p);
    		strcat(temp.p,s.p);
    		return temp;
    	}
    
    
    
    	MyString operator+ (const char* c)
    	{
    		MyString temp;
    		int length = strlen(this->p);
    		temp.p = new char[length+1];
    		strcpy(temp.p,this->p);
    		strcat(temp.p,c);
    		return temp;
    	}
    
    
    	friend MyString operator+ (const char* str, MyString s)
    	{
    		MyString temp;
    		int length1 = strlen(str);
    		int length2 = strlen(s.p);
    		temp.p = new char[length1 + length2 +1];
    		strcpy(temp.p,str);
    		strcat(temp.p,s.p);
    		return temp;
    	}
    
    
    	MyString & operator+=(MyString s)
    	{
    		MyString temp;
    		temp = *this;
    		int length1 = strlen(temp.p);
    		int length2 = strlen(s.p);
    		delete []this->p;
    		this->p = new char[length1 + length2 + 1];
    		strcpy(this->p,temp.p);
    		strcat(this->p,s.p);
    		return *this;
    	}
    
    
    	MyString operator() (int m ,int n)
    	{
    		MyString temp;
    		temp.p = new char[n+1];
    		int i;
    		for (i = m;i < m+n;i++){
    			temp.p[i-m] = this->p[i];
    		}
    		temp.p[n] = 0;
    		return temp;
    	}
    
    
    	friend  ostream & operator << (ostream & os,const MyString & s)
    	{
    		os<<s.p;
    		return os;
    	}
    
    
    
    	int operator<(MyString str)
    	{
    		if(strcmp(this->p,str.p) == -1){
    			return 1;
    		}
    		else return 0;
    	}
    
    
    	int operator>(MyString str)
    	{
    		if(strcmp(this->p,str.p) == 1){
    			return 1;
    		}
    		else return 0;
    	}
    	
    	
    	int operator==(MyString str)
    	{
    		if(strcmp(this->p,str.p) == 0){
    			return 1;
    		}
    		else return 0;
    	}
    
    
    
    };
    
    
    int CompareString( const void * e1, const void * e2)
    {
    	MyString * s1 = (MyString * ) e1;
    	MyString * s2 = (MyString * ) e2;
    	if( * s1 < *s2 )
    	return -1;
    	else if( *s1 == *s2)
    	return 0;
    	else if( *s1 > *s2 )
    	return 1;
    }
    
    
    int main()
    {
    	MyString s1("abcd-"),s2,s3("efgh-"),s4(s1);
    	MyString SArray[4] = {"big","me","about","take"};
    	cout << "1. " << s1 << s2 << s3<< s4<< endl;            //ok
    	s4 = s3;                                            //ok
    	s3 = s1 + s3;
    	cout << "2. " << s1 << endl;
    	cout << "3. " << s2 << endl;
    	cout << "4. " << s3 << endl;
    	cout << "5. " << s4 << endl;
    	cout << "6. " << s1[2] << endl;
    	s2 = s1;
    	s1 = "ijkl-";
    	s1[2] = 'A' ;
    	cout << "7. " << s2 << endl;
    	cout << "8. " << s1 << endl;
    	s1 += "mnop";
    	cout << "9. " << s1 << endl;
    	s4 = "qrst-" + s2;
    	cout << "10. " << s4 << endl;
    	s1 = s2 + s4 + " uvw " + "xyz";
    	cout << "11. " << s1 << endl;
    	qsort(SArray,4,sizeof(MyString),CompareString);
    	for( int i = 0;i < 4;i ++ )
    		cout << SArray[i] << endl;
    	//s1的从下标0开始长度为4的子串
    	cout << s1(0,4) << endl;
    	//s1的从下标5开始长度为10的子串
    	cout << s1(5,10) << endl;
    	return 0;
    }
    
    
    展开全文
  • C++对象数组初始化

    2018-01-30 11:18:00
    C++对象数组初始化 类对象 数组 初始化可以使用构造函数初始化,同时类有不同的构造函数,可以对类对象数组元素使用不同的构造函数; posted on 2018-01-30 ...
  • class C { int a[3]; public: C(int x, int y, int z) : a{x, y, z} { /* ... */ };...如果数组成员构造成本比较高,或者是const的,希望通过初始化列表构造,就很麻烦了。C++03会建议使用指针数组
  • C++数组对象和构造函数

    千次阅读 2014-01-16 20:41:02
    定义数组对象以后,对数组中的对象初始化的方式分为两种: 一种方式是在定义的时候用列表初始化 A a[5] = {A(1),A(2),A(3),A(4),A(5)};一种方式是在定义了数组对象以后,再使用临时对象进行初始化 A b[5]; b[0]...
  • #re: 对象数组初始化的...如果是构造函数为了初始化对象元素生成的,那也是应该调用拷贝初始化构造函数,为什么要调用构造函数?请各位高手,帮我解决,#re: 对象数组初始化的一种方法2007-03-28 21:46ahlongxp@草根...
  • 对象数组初始化

    2019-04-13 07:59:35
    学堂在线 c++程序设计 郑莉 第六章数组 指针 ...对象数组初始化 数组中每一个元素对象被创建时,系统都会调用类构造函数初始化该对象。 通过初始化列表赋值。 例:Point a[2]={Point(1,2),Point(3,4)}; ...
  • c++对象数组初始化

    2020-04-17 16:28:32
    在学习c++对象数组时,无意中发现书中写到的数组初始化,测试过程中发现若自己写上拷贝构造函数,则会报错,而如果形参是常引用居然可以通过。 这里附上参考了一下大佬的博客,关于移动构造函数与复制构造函数 属实...
  • C++数组初始化

    2016-06-11 16:50:28
    C++数组初始化 C++由于在定义的时候不能直接对变量进行初始化,需要在构造函数里面对变量进行初始化。最近在搞STM8单片机上用C++封装各个模块,奇怪的发现竟然不能实现在构造函数里面直接对数组进行初始化。 eg:...
  • 我知道我问的问题很初级 但是 我就是这里有疑问class car{private $name;private $num;public function __construct($name,$num){$this->...为什么要初始化 全局变量;回复内容:我知道我问的...
  • 目录必须使用初始化列表初始化的数据类型各种创建类对象的区别,调用函数的不同**复制构造函数**和**赋值操作符重载函数**自定义类string成员函数指针的定义与使用对象数组初始化类中内嵌对象数组成员,对数组成员...
  • 定义一个关于学生信息的类 ``` class Student {private: char *name; ... Student(char *name="XiaoMing" , char *id = "02", int age = 20, string d = "Hunan");...除普通构造函数外拷贝构造函数可以吗?
  • 数组初始化

    2012-01-16 10:45:42
    函数体外定义的数组: 元素初始化为0函数体内定义的内置数组: 不提供初始化函数体内或者外面的自定义类型: 自动调用默认构造函数初始化 #include int ioutArr[5]; char coutArr[5]; int main() { int ...
  • class R { public: R ( int r1, int r2) : R1(r1),R2(r2){} private:  int R1, R2; };void main() { e.g 1  vector*> r;  for(int i=0;...
  • 我想初始化一个BlackJack游戏的Player对象数组。我已经阅读了很多有关初始化原始对象(如整数...我以为构造函数可以接受一个整数值,并在初始化Player对象的一些成员变量时相应地命名播放器。我想我很亲密,但仍然很...
  • C/C++数组初始化

    2020-09-06 13:07:44
    1、整型数组初始化-栈初始化 //默认初始化 int a[5] = {}; //[0, 0, 0, 0, 0] //全部初始化为0 int a[5] = {0}; //[0, 0, 0, 0, 0] //c++11新写法 int a[5]{}; //[0, 0, 0, 0, 0] 2、字符串的初始化-栈初始化 ...
  • 默认初始化构造函数

    2020-07-17 21:57:04
    //如果定义了一个数组 但是没有提供初始值 //如:X ax [100]; //如果类X 没有默认构造函数 则会产生编译错误 //实例: class X{ public: X() { m = 0; n = 0; }//默认构造函数 X(int v) { m =...
  • C++ 类对象数组初始化

    万次阅读 2018-11-02 21:13:24
    如何给类中定义了带有参数的构造函数的对象数组赋值 class A { public: A(){}//无参构造函数0 A(int i){}//有参构造函数1 A(int i,int j){}//有参构造函数2 }; int main() { A a,b[5];//调用6次无参构造函数...
  • 1、构造函数、拷贝构造函数 如果不写任何构造函数,编译器会自动添加:默认的构造函数、默认的拷贝构造函数。 如果自定义了一个构造函数,而没有自定义拷贝构造函数,编译器会自动添加:默认拷贝构造函数。 ...
  • 动态数组初始化: 对于内置数据类型元素的数组,必须使用()来显示指定程序执行初始化操作,否则程序不执行初始化操作: int *pia = new int[10]; // 每个元素都没有初始化 int *pia2 = new int[10] (); // 每个...
  • 一、一般对象数组初始化 对象数组中的元素同样需要用构造函数初始化。具体哪些元素用哪些构造函数初始化,取决于定义数组时的写法。 #include<iostream> using namespace std; class CSample{ public: ...
  • 对象数组构造函数

    2014-08-13 11:44:08
    定义对象数组时,数组中的各个元素需要构造函数初始化数组能否定义成功,关键在于每个元素都有合适的构造函数,默认构造函数并不是必须的。     1.动态对象数组,对象所属类型必须有public默认构造...

空空如也

空空如也

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

数组初始化构造函数