精华内容
下载资源
问答
  • 假如有OilCar类, ...这样赋值会调用构造函数的输出,但是我不想输出这一段,有没有什么赋值方法可以不输出构造函数的输出呢,只能再多写一个没有输出的构造函数吗。用多态可以吗(我还没学到)。
  • c++对象数组 计算问题

    2015-11-01 02:07:37
    对象数组分别对三个销售员的销售员号、销售件数和销售单价赋值 Commodity com[3]={{101,5,23.5},{102,12,24.56},{103,100,21.5}}; 现已知对购买十件以上者要打98折,要求每件商品的平均售价。 ![图片说明]...
  • C++对象数组作为类成员的问题

    千次阅读 2013-11-23 18:37:49
    //对象数组作为类的成员 } 那样的话对象数组的初始化会变得很麻烦, 因为数组名不能作为左值,所以不可以指针传递的方式赋值。 而且不能通过参数列表(构造函数后面加一个冒号)的方式初始化, 所以只能让类...
    例如:
    class ObjectB{};

    class ObjectA{
    public:
        ObjectB array[5];//对象数组作为类的成员
    }

    那样的话对象数组的初始化会变得很麻烦,
    因为数组名不能作为左值,所以不可以指针传递的方式赋值。
    而且不能通过参数列表(构造函数后面加一个冒号)的方式初始化,
    所以只能让类ObjectA自动调用类ObjectB的无参构造函数.
    ---------------
    #include <iostream.h>
    #include 
    "stdlib.h"
    class   ObjectB{
    public:
        
    int a;
    public:
        ObjectB(
    int m=0)
        
    {
            a
    =m;
        }

    }
    ;
    class   ObjectA
    public:
            ObjectB   Array[
    5]; 
    public
            ObjectA(
    int   *p)
            
    {
                Array[
    0]=ObjectB(p[0]);
                Array[
    1]=ObjectB(p[1]);
                Array[
    2]=ObjectB(p[2]);
            }
     
    }
    ;

    int main()
    {
        
    int p[5]={0,2,2,3,4};
        ObjectA am
    =ObjectA(p);
        cout
    <<am.Array[1].a<<endl;
        
    return 0;
    }

    ---------------

    我们可以使用替代方式:
    class A{};

    classB{
    public:
        A*a;//A类型的指针作为类的成员
    }
    同样带来很大的问题,
    (1)浅拷贝,深拷贝的问题,除非重载拷贝构造函数,类B才能实现深拷贝,因为成员中有指针,所以无法简单的用拷贝构造函数生成一个新对象,而用无参构造函数生成的新对象也会有问题,因为里面的指针一般都默认为NULL了。

    重载拷贝构造函数的时候需要申请一定长度的内存,将拷贝对象的指针所指向的空间拷贝到新申请的空间,再进行操作。注意申请后要释放。
    一个拷贝构造函数的例子
    SparseMatrix::SparseMatrix(const SparseMatrix&s)
        
    {
          Rows
    =s.Rows;
       Cols
    =s.Cols;
       Count
    =s.Count;
       smArray
    =new Trituple[6];
    //此处还需要复制对象
        }


    ----------------------
    补充知识:
    ------------------http://www.ksarea.com/articles/20070829_memory-partition-stack-heap-difference.html

    C/C++应该是大学里最先接触的编程语言,它们的重要性不言而喻。但是我始终抱着“数组名就是指针”的错误信条到现在,可能是因为大学老师错误的讲解使我一直保留着这种误解。指针是C/C++语言的特色,而数组名与指针有太多的相似,甚至很多时候,数组名可以作为指针使用,所以也难免在学习中将两者混淆。这里介绍下指针和数组名的区别:

    1.指针和数组名占据的内存空间大小不一样,如下程序1:

    char str[10];
    char *pstr=str;
    cout<<
    cout<<sizeof

    第一行输出结果是:10,第二行输出结果是:4

    从这里我们可以看出:数组名对应着(而不是指向)一块内存(数组所占的内存区域)或者说是指代数组这种数据结构,其地址与容量在生命期内保持不变,只有数组的内容可以改变。指针对应着一个占据4个字节(Win32)的内存区域,而指向这4个字节所存储的地址所对应的内存单元,它可以指向任意类型的内存块。因此,sizeof(str)值为数组占据的内存空间大小即10个字节,而sizeof(pstr)值为指针的值占据的内存空间大小即4个字节。

    2.数组名不是指针,但是在一定的情况下转换为指代数组的首地址的指针,而这个数组名转为的指针只能是指针常量。
    在以下两种情况下才能进行这种转换:
    a.在程序1第二行代码中,将数组名直接赋值给指针,此时数组名转换为指向数组的首单元的常量指针。
    b.直接将数组名作为指针形参的时候,数组名则转换为指向数组的首单元的常量指针进行传递,如下程序2:

    void fun(char str[])
    {
    cout<<
    str++;
    }
    void main()
    {

    char str1[5];
    fun(str1);

    }

    注意:数组名作为函数形参进行传递时,在子函数体内,它已经不再是一个指针常量,而是变成一个真正的指针,可以进行增减等操作,可以被修改。所以程序2中子程序第一条语句输出的sizeof(str)的值为4.

    既然数组名可以被看作指针常量,而常量是不能修改的,那么如下代码是不允许的:

    char str[10];
    str++;

    但如下代码则合法的:

    char str[10];
    char *pstr=str;
    pstr++;

    3.使用指针访问数组和使用数组名访问数组本质不同。
    例如:

    char str[7]=”ksarea”;
    char *pstr=str;
    cout<<<


    其中str[3]和pstr[3]返回的都是字符’r',但是编译器产生的执行代码却不一样。对于str[3],执行代码是从str开始,向后移动两个字节,然后取出其中的字符;而对于pstr[3],执行代码是从pstr中取出地址,然后在其上加3,然后取出对应内存中的字符。当然,如果pstr是指向int型的指针,那么pstr[3]的处理过程是从pstr中取出地址,然后在其上加上3*sizeof(int),最后取出对应内存中的字符,其他的数据类型一次类推。
    展开全文
  • C++对象数组

    2021-01-19 10:39:46
    对象数组 对象数组的定义与访问 定义对象数组 类名 数组名[元素个数] 访问对象数组元素 通过下标访问 数组名[下标].成员名 对象数组初始化 数组中每一个元素对象被创建时,系统都会调用类构造函数初始化该对象 ...

    对象数组

    对象数组的定义与访问

    • 定义对象数组
      类名 数组名[元素个数]
    • 访问对象数组元素
      通过下标访问
      数组名[下标].成员名

    对象数组初始化

    • 数组中每一个元素对象被创建时,系统都会调用类构造函数初始化该对象
    • 通过初始化列表赋值
      例:Point a[2]={Point(1,2),Point(3,4)}
    • 如果没有为数组元素指定显式初始值,数组元素便使用默认值初始化(调用默认构造函数)

    数组元素所属类的构造函数

    • 元素所属的类不声明构造函数,则采用默认构造函数。

    • 各元素对象的初值要求为相同的值时,可以声明具有默认形参值的构造函数。

    • 各元素对象的初值要求为不同的值时,需要声明带形参的构造函数。

    • 当数组中每一个对象被删除时,系统都要调用一次析构函数。

    对象数组应用举例

    //Point.h
    #ifndef _POINT_H
    #define _POINT_H
    class Point { //类的定义
    	public: //外部接口
    	Point();
    	Point(int x, int y);
    	~Point();//析构函数
    	void move(int newX,int newY);
    	int getX() const { return x; }
    	int getY() const { return y; }
    	static void showCount(); //静态函数成员
    	private: //私有数据成员
    	int x, y;
    };
    #endif //_POINT_H
    //Point.cpp
    #include <iostream>
    #include "Point.h"
    using namespace std;
    Point::Point() : x(0), y(0) {
    	cout << "Default Constructor called." << endl;
    }
    Point::Point(int x, int y) : x(x), y(y) {
    	cout << "Constructor called." << endl;
    }
    Point::~Point() {
    	cout << "Destructor called." << endl;
    }
    void Point::move(int newX,int newY) {
    	cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
    	x = newX;
    	y = newY;
    }
    //6-3.cpp
    #include "Point.h"
    #include <iostream>
    using namespace std;
    int main() {
    	cout << "Entering main..." << endl;
    	Point a[2];
    	for(int i = 0; i < 2; i++)
    	a[i].move(i + 10, i + 20);
    	cout << "Exiting main..." << endl;
    	return 0;
    }
    

    在这里插入图片描述

    展开全文
  • C++对象数组

    2020-02-22 15:50:29
    对象数组的定义与访问 定义对象数组   类名 数组名[元素个数]; 访问对象数组元素   通过下标访问   数组名[下标].成员名 对象数组初始化   数组中每一个元素对象被创建时,系统都会调用类构造函数初始化该...

    对象数组的定义与访问

    定义对象数组
      类名 数组名[元素个数];

    访问对象数组元素
      通过下标访问
      数组名[下标].成员名

    对象数组初始化

      数组中每一个元素对象被创建时,系统都会调用类构造函数初始化该对象。

    通过初始化列表赋值。
    例:Point a[2]={Point(1,2),Point(3,4)};

      如果没有为数组元素指定显式初始值,数组元素便使用默认值初始化(调用默认构造函数)。

    数组元素所属类的构造函数

      当数组中每一个对象被删除时,系统都要调用一次析构函数。

    //Point.h
    
    #ifndef _POINT_H
    #define _POINT_H
    
    class Point { //类的定义
    
    public: //外部接口
    	Point();
    	Point(int x, int y);
    	~Point();
    	void move(int newX,int newY);
    	int getX() const { return x; }
    	int getY() const { return y; }
    	static void showCount(); //静态函数成员
    
    private: //私有数据成员
    	int x, y;
    };
    #endif //_POINT_H
    
    //Point.cpp
    
    #include <iostream>
    #include "Point.h"
    using namespace std;
    
    Point::Point() : x(0), y(0) {
    	cout << "Default Constructor called." << endl;
    }
    
    Point::Point(int x, int y) : x(x), y(y) {
    	cout << "Constructor called." << endl;
    }
    
    Point::~Point() {
    	cout << "Destructor called." << endl;
    }
    
    void Point::move(int newX,int newY) {
    	cout << "Moving the point to (" << newX << ", " << newY << ")" << endl;
    	x = newX;
    	y = newY;
    
    }
    
    //6-3.cpp
    #include "Point.h"
    #include <iostream>
    using namespace std;
    
    int main() {
    	cout << "Entering main..." << endl;
    	Point a[2];
    
    	for(int i = 0; i < 2; i++)
    		a[i].move(i + 10, i + 20);
    		cout << "Exiting main..." << endl;
    
    return 0;
    }
    

    在这里插入图片描述

    展开全文
  • 对象的动态建立和释放   1. 动态分配内存和释放内存 new delete   2. 用new运算符动态分配内存后,将返回的一个指向新对象的指针的值,用户通过这个地址来访问对象  定义: Time *pt1=new Time; Time *pt2; ...

    对象的动态建立和释放

      1. 动态分配内存和释放内存

    	new  delete
    

      2. 用new运算符动态分配内存后,将返回的一个指向新对象的指针的值,用户通过这个地址来访问对象

     定义:
    Time *pt1=new Time;
    Time *pt2;
    pt2=new Time(8,28,80);  //初始化
    
    pt2->show_time();   //访问
    
     用delete运算符释放对象
    delete pt1;
    
     box类
    #include<iostream>
    using namespace std;
    class Box
    {
    public:
        Box(int w,int l,int h):
        ~box();
        int width;
        int length;
        int height;
    
    };
    
    Box::Box(int w,int l,int h)
    {
        ...
    }
    Box::~box()
    {
        ....
    }
    
    int main()
    {
        Box *p=new Box(12,12,13);  //建立
        ......
        delete p;       //释放
        return 0;
    }
    

    建立对象数组

     1. 固定大小的数组
    const int N=100;
    Time t[N];
    
     2. 动态数组
    int n;
    Time *t;
    cin>>n;
    。。。
    t=new Time[n];
    delete []t;
    

    建立指针数组

    建立占用空间小的指针数组,灵活处理占用空间大的对象集合;
    
    const int N=100;
    Time *t[N]={NULL};
    
    int i;
    ....
    int =3;
    if(t[1]==NULL)
        t[i]=new Time(10,40,10);
    
    if=(t[i]=NULL)
        delete t[i];
    

    对象的赋值和复制

      1.对象的赋值:

    对象1和2是同一个类
    对象1=对象2

      2.对象的复制

      类名 对象2(对象1);
    
      Box box2(box1);
    

    原理:编译调用默认复制构造函数

    Box::Box(const Box &b)  //不被修改
    {
        h=B.h;
    }
    

        1. c的复制初始化:

    int a=5;
    string name="l,he";
    

        2. C++的复制初始化

    int a(5);
    string name("l.he");
    string s(nbame);
    
    Time t1;
    Time t2(8,30,20);
    Time t3(t1);
    

    何时通过复制构造函数对对象进行复制

        1.新建立一个对象:利用构造函数进行初始化

       Box box(box2);
    

        2.当函数的参数为类的对象:形参传递给实参

    void fun(Box b) //形式参数为   Box类
    {
    
    }
    
    int main()
    {
        Box box1(12,12.18);
        fun(box1)k
        return 0;
    }
    

        3.返回值为类的对象:返回给调用处

    Box f()     //返回值为BOX类
    {
        box box1(12,12,15);
        retrun box1;
    }
    
    int mian()
    {
        Box box2;
        box2=f();
    }
    

    深复制:当指针数据成员时候,必须深复制:先给所指向的指针分配空间,再做其他操作

    class  Test
    {
    private:
        int x;
        char &str;
    public:
         Test(int n,char *s)
         {
             x=n;
             int m=strlen(s)+1; //计算传入s的值的长度
             str=new char[m];   //分配空间
             strcpy(str,s);
         }
    
         Test(const Test &s)
         {
             x= c.x;
             int m=strlen(s.str); 
             str=new char[m];
             strcpy(str,s.str);
         }
         ~Test(const Test &s)
         {
             delete str;        //释放
         }
    
         void show()
         {
             cout<<x<<","<<str<<endl;
         }
    
    };
    
    展开全文
  • 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次无参构造函数...
  • 2维数组赋值.cpp

    2020-02-23 11:06:38
    C++是C语言的继承,它既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时,还可以进行基于...
  • C++数组的声明与赋值

    千次阅读 2014-03-05 14:01:21
    1、C++中提供了两种类似于vector和迭代器类型的低级复合类型-数组和指针。首先,数组和vector区别:数组的长度是固定的,数组一经创建,就不允许添加新的元素。而指针可以像迭代器一样用于遍历和检查数组中的元素。 ...
  • C++ 对象数组

    2010-03-16 17:19:00
    对象数组的定义、赋值和引用与普通数组一样,只是数组的元素与普通数组不同,它是同类的若干个对象。 1. 对象数组的定义 对象数组定义格式如下: []... 其中,指出该数组元素是属于该类的对象,方括号内的给出某...
  • 2维数组赋值(4).cpp

    2020-02-23 11:08:24
    C++是C语言的继承,它既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时,还可以进行基于...
  • 2维数组赋值(3).cpp

    2020-02-23 11:07:50
    C++是C语言的继承,它既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时,还可以进行基于...
  • 2维数组赋值(2).cpp

    2020-02-23 11:07:16
    C++是C语言的继承,它既可以进行C语言的过程化程序设计,又可以进行以抽象数据类型为特点的基于对象的程序设计,还可以进行以继承和多态为特点的面向对象的程序设计。C++擅长面向对象程序设计的同时,还可以进行基于...
  • 一.对象数组 对象数组是指每一个数组元素都是对象的数组,也就是说,若一个类有若干个对象,可以把这一系列的对象用一个数组来存放。对象数组的元素是对象,不仅具有...1>用只有一个参数的构造函数给对象数组赋值:如
  • malloc、calloc、realloc返回一个 void 指针,C++不允许将 void 指针赋值给其他任何指针,必须强转。 malloc、calloc、realloc可能申请内存失败,所以必须根据返回值确定是否申请成功。 malloc、calloc、realloc不会...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 754
精华内容 301
关键字:

c++对象数组赋值

c++ 订阅