类数组初始化,c++类对象数组初始化的几种方法

类数组初始化,c++类对象数组初始化的几种方法详细介绍

本文目录一览： c++类对象数组初始化的几种方法

类对象数组初始化
如有一个如下类：
class EquipmentPiece {
private:
int IDNumber;
public:
EquipmentPiece(int IDNumber) : IDNumber(IDNumber) {};
};
以下列出几种初始化的方法：

、对象数组

int ID1, ID2, ID3;

EquipmentPiece bestPieces[] = { EquipmentPiece(ID1), EquipmentPiece(ID2), EquipmentPiece(ID3) };

注意：

EquipmentPiece bestPieces[10]; //no appropriate default constructor available

EquipmentPiece *bestPieces = new EquipmentPiece[10]; //no appropriate default constructor available

当然，如果你将构造函数参数全都设了默认值，以上两种写法也成功，如将类中构造函数修改如下：

...

EquipmentPiece(int IDNumber = 0) : IDNumber(IDNumber) {};

...

、指针数组

typedef EquipmentPiece* PEP; //PEP是个指向EquipmentPiece的指针

PEP bestPieces[10]; //等同于 PEP *bestPieces = new PEP[10];

//然后初始化

for(int i = 0; i < 10; i++){

bestPieces[i] = new EquipmentPiece( IDNumber );

}

注意：

要记得将此数组所指的所有对象删除。如果忘了会产生资源泄露。还有就是该方法与对象数组相比需要额外内存用于存放指针。(过度使用内存 这一问题可以避免，见第三种方法)

、使用placement new

方法是：先为此数组分配raw memory，然后使用"placement new"在这块内存上构造EquipmentPiece objects;

//分配足够的raw memory，给一个预备容纳10个EquipmentPiece objects的数组使用

void *rawMemory = operator new(10*sizeof(EquipmentPiece));

//让bestPieces指向此内存，使这块内存被视为一个EquipmentPiece数组

EquipmentPiece *bestPieces = reinterpret_cast

(rawMemory);

//利用"placement new"构造这块内存中的EquipmentPiece objects。

int IDNumber = 0;

for(int i = 0; i < 10; i++){

new (&bestPieces[i]) EquipmentPiece( IDNumber );

}

注意：该方法维护比较困难。在数组内对象结束生命时，要以手动方式调用destructors，最后还得调用operator delete释放raw memory。

//将bestPieces中对象以构造次序的反序析构掉

for(i = 0; i < 10; i++){

bestPieces[i].~EquipmentPiece();

}

//释放raw memory

operator delete (rawMemory);

java数组类初始化如何赋值

总结了java数组的初始化的两种方法如下：
1、最简单的方法是直接赋值，如：
一维数组：
int[]
num
=
{21,34,2,-9,987,0,-89};//创建一个一维数组，并赋7个初始值
二维数组：
int[][]
num2
=
{{21,22},{34,35}};//创建一个二维数组，并赋2个初始值
2、先创建一个数组对象出来，再进行循环赋值，如：
一维数组：
int[]
num3
=
new
int[5];//先创建一个5长度的数组对象
for(int
i=0;i
<num3.length;i++){ 之后进行循环遍历对数组进行赋值
num3[i]

=

i;

}

二维数组：

int[][]

num4

=

new

int[5][2];//先创建一个二维数组对象

for(int

i=0;i
<num3.length;i++){ 之后进行循环遍历对数组进行赋值
for(int

j=0;j
<num4[i].length;j++){
num4[i][j]

=

j;

}

}

Comparable [] a=new Comparable[4];

for(int i = 0; i < a.length; i ++) {

//参数定死看样子影响不大吧

a[i] = new new Comparable(i);

}

如果你的数组赋值都很有规律可以用循环来做，如果不是的话那就只能这样了！！

但是你也可以这样

int【】 a={23，34，432}；

Comparable[] s={new Comparable(3),new Comparable(20),new Comparable(13)};

估计也只能这样子了.这么写不能直接指定数组的长度.

数据特别多的话,最好是把你的数据用个int数组包装起来,再写个循环.

Comparable [] a = new Comparable[]{new Comparable(3),new Comparable(20),new Comparable(13)};

这样写代码，阅读感不好。

总结了java数组的初始化的两种方法如下：

1、最简单的方法是直接赋值，如：

一维数组：

int[] num = {21,34,2,-9,987,0,-89};//创建一个一维数组，并赋7个初始值

二维数组：

int[][] num2 = {{21,22},{34,35}};//创建一个二维数组，并赋2个初始值

2、先创建一个数组对象出来，再进行循环赋值，如：

一维数组：

int[] num3 = new int[5];//先创建一个5长度的数组对象

for(int i=0;i
<num3.length;i++){ 之后进行循环遍历对数组进行赋值
num3[i] = i;

}

二维数组：

int[][] num4 = new int[5][2];//先创建一个二维数组对象

for(int i=0;i
<num3.length;i++){ 之后进行循环遍历对数组进行赋值
for(int j=0;j
<num4[i].length;j++){
num4[i][j] = j;

}

}
</num4[i].length;j++){

</num4[i].length;j++){

java类中构造函数中：数组怎样初始化

数组一般都是用FOR循环初始化较多吧，如：
for(int i =0;i
<array.length;i++){
array[i]=2;

}

public class A{

int arr [];

public A(int arr[]){

this.arr = arr;

}

}

class B{

public void demo(){

int arr[] = {2,2,2,2,2,2};

new A(arr );

}

}

int arraySize = 10; // array size: 10 elements

int[] a = new int[arraySize ]; // declare and allocate memory

for(int i=0; i < arraySize; i++) { // initialization

a[i] = 2; // set every element to integer 2

}

1、java构造函数--数组 在构造函数中初始化数组，如 public class array { private int [][] matrix; public array(int r,int c) { matrix=new matrix[r][c]; } }

matrix=new matrix[r][c];

2、这里是new int[][]; java中8个基本数据类型都是有默认值的，int默认值为0 ，

3、所以数组中默认都为0.

4、但是切记有默认值的变量必须是类的属性，方法中局部变量必须赋值才可以使用。
</array.length;i++){

类中如何初始化数组？

如果数组是类里面的成员，那必须是要一个个赋值，没其他的办法的，因为 int horizontal[8]={2,1,-1,-2,-2,-1,1,2} 不是赋值，而是初始化
可以不用一个个地赋值，用memcpy或memmove就行了。
class CTest
{
private:
int array[8];
};
CTest::CTest(void)
{
int horizontal[8]={2,1,-1,-2,-2,-1,1,2};
memcpy(array, horizontal, sizeof(array)); //建议用memmove
}

C++类中怎样对数组用构造函数初始化

错误的原因是你在类定义里面做得初始化，把初始化部分放在类CComputer的构造函数里就ok了。
初始化的位置错误，我说得绝对没问题，可以在类定义中声明类，但是初始化一定要放在成员函数里。
有两种方法，一种是使用初始化列表，一种是C++11提供的类内初始化。初始化的参数通常为列表，即数组的列表初始化，对于char数组还可以用字符串字面值作为初始化的参数。
数组通常使用列表进行初始化，如果列表元素小于数组大小，则剩下的元素默认初始化（对于函数内的内置类型，其值不确定）：
int main(){ int a[3] = {0, 0, 0}; int b[] = {0, 0, 0}; int c[3] = {0} //c[0]=0，c[1]和c[2]值不确定，依赖于编译器。 return 0;}在类里也可以用列表来初始化：
#include

struct A { // C++11新特性，当构造函数未初始化某个元素时，初始化为类内初始值 int a[3] = {0, 0, 0}; A() = default; //C++11新特性，指出由编译器来合成默认构造函数 A(int x, int y, int z) : a({x, y, z}) {}};int main() { A a; std::cout << a.a[0]; //0 A b(1, 1, 1); std::cout << b.a[0]; //1 return 0;}特殊地，char数组可以用字符串字面值来初始化：

struct A { char s[6] = "hello"; //必须预留一个'\0'，因此s的大小至少为6};

C++类数组成员初始化问题

数组初始化是指在定义数组时为数组元素提供值。所以：
CRect m_rect[4] = {CRect(),CRect(),CRect(),CRect()}; ——是对的
而
Crect m_rect[4];
m_rect = {CRect(),CRect(),CRect(),CRect()};
——是错误的。
m_rect = {CRect(),CRect(),CRect(),CRect()};
数组名怎么能=后面那么多。。。
不是迫不得已不要用全局变量，即使用也别写在头文件中。写在源文件中，在使用的地方声明extern 即可。
m_rect = {CRect(),CRect(),CRect(),CRect()}; 这句是在给数组赋值。
CRect m_rect[4] = {CRect(),CRect(),CRect(),CRect()}; 这句是在给数组初始化。
简单点儿，比如你定义一个 int a[4] = { 0, 1, 2, 3 }; 这个是没有问题的，但在声明之后你再写 a = { 0, 1, 2, 3 }; ，这个就过不了了。一个意思。
在声明的时候可以这样写，是初始化。在声明之后编译器会认为你是在给数组赋值。但数组是没有赋值操作的。所以会有编译错误。

C++一个类里面创建其他类的数组对象，初始化问题

构造函数设置默认值
student
(int
m,char
*n);只在这儿改就好，改为
student
(int
m=12,char
*n="lalala");
这样的话，下面那个student();就不能要了，编译器将分不清楚这两个构造函数...
这些东东，随便一本入门教程上应该都有吧....建议按一个例子学完...
第一种先是定义3个指向Student类的指针数组，然后每一个指向这个类的指针元素都用构造函数初始化，而第二种就是定义一个指针，动态分配3个数组，数组里面的元素就是那个类的对象，
简单来说，第一种是定义指针数组，而数组里面的元素是那个类的对象的地址，
而第二种就是直接是3个数组，存的元素直接是类的对象本身，而不是地址。
要看你的构造函数是怎样了，如果是默认构造函数的话，在定义的时候就调用了默认构造函数，所以已经初始化了，如果不是默认构造函数的话就是可以自己带参数去赋值
第二个问题，每个new
对应每个delete
所以你用完之后都要delete掉他。不能重复delete喔，一次就好了。

C语言数组的初始化表示方法

在C语言中,数组的初始化有以下几种方式:
1、定义的时候同时初始化:
int array[10] = {1,2,3,4,5};
2、定义的时候不指定数组大小,由初始化的数组元素来确定大小:
int array[] = {1,2,3,4,5};
3、先定义变量,然后初始化.注意点:定义变量时必须制定数组的大小.此时只能对数组变量成员元素逐一赋值,不能批量赋值.
// int array[]; //错误用法
int array[12];
// array = {1, 2, 3}; //错误用法.
array[0] = 1;
array[1] = 2;
array[2] = 3;
4、只有一种情况,在作为方法的形式参数时,可以不指定数组的大小.这时传入方法的是数组的首地址,所以在方法内部是无法得到数组长度的,数组长度必须作为参数传入函数.
void test()
{
int array[] = {1,2,3,4,5};
int length = sizeof(array)/sizeof(int);
int result = sumOfArray(array, length);
printf("%d",result);
}
int sumOfArray(int array[], int length)
{
int result = 0;
for (int i=0; i
<length; i++)
{

result += array[i];

}

return result;

}

扩展资料

C语言数组构建：

1、遵循原则

申请的时候从外层往里层，逐层申请；

释放的时候从里层往外层，逐层释放。

2、构建所需指针

对于构建一维动态数组，需要一维指针；

对于二维，则需要一维，二维指针；

三维需要一，二，三维指针；

依此类推。

参考资料

百度百科-C语言

一般对数组初始化可以用以下方法实现:

（1）在定义数组时对数组元素赋以初值。如:

static int a［10］=｛0，1，2，3，4，5，6，7，8，9｝;经过上面的定义和初始化后，a［0］=0，a［1］=1，…，a［9］=9。

（2）初始化时可以只对一部分元素赋初值。例如:

static int a［10］=｛0，1，2，3，4｝;定义的数组有10个元素，但只对其中前5个元素赋了初值，后5个元素初值为0。

（3）如果想使一个数组的元素值全部为0，可以用下面的方法:

static int a［10］=｛0，0，0，0，0，0，0，0，0，0｝;不能用:

static int a［10］=｛0*10｝;如果对static型数组不赋初值，系统会对定义的所有数组元素自动赋以0值。

（4）在对全部数组元素赋初值时，可以不指定数组长度。

C语言数组的初始化表示方法有4种，分别是：

1、定义的同时进行初始化，我们同样用数组的初始化引出结构体的初始化，我们知道数组在定义的同时进行初始化的代码如下：

int nums[] = {1, 3, 5}；

由此可推出结构体在定义的同时进行初始化的代码如下：

struct Person p = {"lee", 23, 1.8};

2、先定义再进行初始化，这种初始化方法其实昨天的内容里已经写过了，代码如下：

struct Person p;

p.name = "lee";

p.age = 23;

p.height = 1.8;

我们知道数据定义好后就不能对其进行一次性初始化了，比如如下代码是编译不通过的。

int nums[3];

num = {1, 2, 3}

3、第三种结构体比较例外，它可以这样做，只不过需要对其进行一下强制类型转换，代码如下：

struct Person p;

p = (struct Person){"xq, 8, 8.8}

4、指定将数据赋值给指定的属性，数组中我们见过这种写法，代码如下：

int nums[3] = {[0] = 2, [2] = 1, [1] = 2};

我们可以为不同的索引指定值，并不需要一定要按顺序来，所以数组可以，结构体是否可以呢，当然，代码如下：

struct Person p = {.height = 1.8, .name = "lee", .age = 23};

C语言数组的初始化表示方法有4种，分别是：

1、定义的同时进行初始化，我们同样用数组的初始化引出结构体的初始化，我们知道数组在定义的同时进行初始化的代码如下：

int nums[] = {1, 3, 5}；

由此可推出结构体在定义的同时进行初始化的代码如下：

struct Person p = {"lee", 23, 1.8};

2、先定义再进行初始化，这种初始化方法其实昨天的内容里已经写过了，代码如下：

struct Person p;

p.name = "lee";

p.age = 23;

p.height = 1.8;

我们知道数据定义好后就不能对其进行一次性初始化了，比如如下代码是编译不通过的。

int nums[3];

num = {1, 2, 3}

3、第三种结构体比较例外，它可以这样做，只不过需要对其进行一下强制类型转换，代码如下：

struct Person p;

p = (struct Person){"xq, 8, 8.8}

4、指定将数据赋值给指定的属性，数组中我们见过这种写法，代码如下：

int nums[3] = {[0] = 2, [2] = 1, [1] = 2};

我们可以为不同的索引指定值，并不需要一定要按顺序来，所以数组可以，结构体是否可以呢，当然，代码如下：

struct Person p = {.height = 1.8, .name = "lee", .age = 23};

数组的初始化：

int a[]={1,2,3}; 这种方式初始化，大括号里写了几个元素那么数组里就有几个元素，相当于int a[3]={1,2,3}

int a[3]={0}; 这样是将a中的所有元素初始化为0；

int a[4]={1,2}; 这样是将a[0]初始化为1，a[1]初始化为2，其他的初始化为0

不是inta[] 而是例如int a[10]这种。括号内一定要有个常量数字。

我们可以这样定义

#define N 5

int a[N]

这表明了数组名为a；数组有5个元素；分别是a[0]到a[4];

对于数组来说；数组是变量的集合，因此数组也具有与变量相同的数据类型和储存类型。数组的类型就是它所有的变量的类型。在定义数组时，应在数组名前对数组的类型加以确定。如上面的int a[10];则表明了数组内元素均为整形。

所有当表示浮点型可以定义为例如float a[10]。 举例如下：

扩展资料数组名是由用户命名的C语言标识符，要遵循标识符命名规则。数组名表示数组存储区域的首地址。数组的首地址也就是第一个元素的地址。数组名是一个地址常量，不能对它赋值。

数组名后是由方括号括起来的常量表达式，不能使用其他括号

怎样在类里用构造函数初始化二维数组

#include

using namespace std;

class matrix

{

public:

matrix(int a1[3][2])

{ for(int i=0;i<3;i++)

for(int j=0;j<2;j++)

a[i][j]=a1[i][j];

}

private:

int a[3][2];

};

void main()

{

int A[3][2] = {1,2,3,4,5,6};

matrix a(A);

}

matrix a(1,2,3,4,5,6);于matrix(int a1[3][2])

不一致。现在可以了

上述代码存在两个问题：

1. 构造函数的参数列表定义为一个`int a1[3][2]`二维数组，但是在调用时使用了6个整数（1, 2, 3, 4, 5, 6）。应该将构造函数的形参改为`int a1[3][2]`，并且调用时传入一个符合要求的二维数组。

2. 在调用构造函数时，只创建了一个`matrix a`对象，但是没有将构造函数中的参数传递给对象。应该修改为`matrix a( {{1,2}, {3,4}, {5,6}} )`，使用C++11标准中的列表初始化方式，将一个符合要求的二维数组作为参数传递给构造函数。

以下是修改后的示例代码：

```cpp

#include

using namespace std;

class matrix {

public:

matrix(int a1[3][2]) {

for (int i = 0; i < 3; i++) {

for (int j = 0; j < 2; j++) {

a[i][j] = a1[i][j];

}

}

}

private:

int a[3][2];

};

int main() {

matrix a( {{1,2}, {3,4}, {5,6}} ); // 使用二维数组初始化对象

return 0;

}

```

在上述代码中，我们定义了一个类`matrix`，并在其中实现了一个接受二维数组参数的构造函数。在main函数中，我们创建了一个符合要求的二维数组，并使用其来初始化一个`matrix`对象。

运行以上代码，输出结果为空，说明程序运行正确。