对象数组可以当实参传入吗
时间: 2024-03-16 21:44:17 浏览: 15
是的,对象数组可以当实参传入。在函数调用时,可以将对象数组作为参数传递给函数。函数可以接收并处理该数组,就像处理其他类型的数组一样。例如,假设有一个函数`printStudents()`,可以接收一个学生对象数组作为参数,并打印每个学生的信息。可以像下面这样将对象数组作为参数传递给该函数:
```
Student[] students = new Student[3]; // 创建学生对象数组
// 填充学生对象数组
students[0] = new Student("Tom", 20);
students[1] = new Student("Jerry", 22);
students[2] = new Student("Mickey", 21);
printStudents(students); // 将学生对象数组作为参数传递给函数
```
在函数内部,可以使用循环遍历该数组,并访问每个学生对象的属性和方法,如下所示:
```
public static void printStudents(Student[] students) {
for (int i = 0; i < students.length; i++) {
System.out.println("Name: " + students[i].getName() + ", Age: " + students[i].getAge());
}
}
```
相关问题
因为String类型是一个不可变类型,而以new String("字符串")这种方式创建字符串时,当你传入实参,实参其实已经在常量池创建了一个字符串original,等同于String original = "字符串"
非常正确!Java 中的 String 类型是一个不可变类型,是基于字符数组实现的,它的值在创建后是不可更改的。而使用 `new String("字符串")` 的方式创建字符串时,实参 `"字符串"` 会首先在常量池中创建一个字符串常量,然后使用这个常量创建一个新的字符串对象。如果常量池中已经存在这个字符串常量,则直接使用这个常量创建字符串对象,不会创建新的对象。因此,当使用 `new String("字符串")` 创建字符串时,实际上是复制了一个已有的字符串对象,这个新对象和原来的对象在内存中的地址不同,但它们的值相同。为了避免创建不必要的对象,我们通常建议使用字符串字面量的方式创建字符串,例如 `"字符串"`,这种方式会直接在常量池中创建字符串常量,不需要创建新的对象。
利用c++程序编写下面内容。 1.在类内声明与定义构造函数,给数据成员(年龄age、学号num 性别sex、姓名name)赋默认值(例如:18,202311,m, zhangsan) - . 2.定义一个对象stu1与对象指针p1,通过指针p1调用display()函数,查看构造函数给的默认值是否正确; 3. 在类内再声明一个构造函数,在类外定义,实现函数重载(此处不赋默认值);4.定义一个对象stu2,并给实参完成初始化,然后通过定义指针p2来访问stu2的display(),查看初始化的值是否正确;5.定义一个对象数组stu【3】,通过指针来依次输出3位学生的信息
好的,我来回答你的问题。
1. 在类内声明与定义构造函数,给数据成员赋默认值的代码如下:
```cpp
class Student {
public:
Student() : age(18), num("202311"), sex('m'), name("zhangsan") {}
Student(int a, string n, char s, string nu) : age(a), name(n), sex(s), num(nu) {}
void display() {
cout << "Name: " << name << endl;
cout << "Age: " << age << endl;
cout << "Sex: " << sex << endl;
cout << "Number: " << num << endl;
}
private:
int age;
string num;
char sex;
string name;
};
```
2. 定义对象stu1和对象指针p1,并通过指针p1调用display()函数的代码如下:
```cpp
int main() {
Student stu1;
stu1.display();
Student* p1 = &stu1;
p1->display();
return 0;
}
```
这段代码会输出以下内容:
```
Name: zhangsan
Age: 18
Sex: m
Number: 202311
Name: zhangsan
Age: 18
Sex: m
Number: 202311
```
我们可以看到,对象stu1和对象指针p1调用display()函数输出的结果相同,说明对象指针p1调用函数的方式是正确的。
3. 在类内再声明一个构造函数,在类外定义,实现函数重载(此处不赋默认值)的代码如下:
```cpp
class Student {
public:
Student() : age(18), num("202311"), sex('m'), name("zhangsan") {}
Student(int a, string n, char s, string nu) : age(a), name(n), sex(s), num(nu) {}
Student(string n, string nu, char s, int a) : age(a), num(nu), sex(s), name(n) {}
void display() {
cout << "Name: " << name << endl;
cout << "Age: " << age << endl;
cout << "Sex: " << sex << endl;
cout << "Number: " << num << endl;
}
private:
int age;
string num;
char sex;
string name;
};
```
这段代码中,我们新增了一个构造函数,它的参数列表与之前的构造函数不同,实现了函数重载。在类外定义这个构造函数的代码如下:
```cpp
Student::Student(string n, string nu, char s, int a) : age(a), num(nu), sex(s), name(n) {}
```
这段代码实现了构造函数的定义,并赋予了它传入参数的值。
4. 定义对象stu2,并给实参完成初始化,然后通过定义指针p2来访问stu2的display(),查看初始化的值是否正确的代码如下:
```cpp
int main() {
Student stu2(20, "lisi", 'f', "202312");
stu2.display();
Student* p2 = &stu2;
p2->display();
return 0;
}
```
这段代码会输出以下内容:
```
Name: lisi
Age: 20
Sex: f
Number: 202312
Name: lisi
Age: 20
Sex: f
Number: 202312
```
我们可以看到,对象stu2和对象指针p2调用display()函数输出的结果相同,说明对象指针p2调用函数的方式是正确的,并且初始化的值也是正确的。
5. 定义对象数组stu[3],通过指针来依次输出3位学生的信息的代码如下:
```cpp
int main() {
Student stu[3] = {
Student(19, "zhangsan", 'm', "202311"),
Student(20, "lisi", 'f', "202312"),
Student(18, "wangwu", 'm', "202313")
};
Student* p = stu;
for (int i = 0; i < 3; i++) {
p->display();
p++;
}
return 0;
}
```
这段代码会依次输出三位学生的信息,输出结果如下:
```
Name: zhangsan
Age: 19
Sex: m
Number: 202311
Name: lisi
Age: 20
Sex: f
Number: 202312
Name: wangwu
Age: 18
Sex: m
Number: 202313
```
我们可以看到,通过指针p依次输出对象数组stu中的三位学生的信息,输出的结果是正确的。