精华内容
下载资源
问答
  • 对象指针数组

    千次阅读 2019-05-20 13:10:28
    创建对象指针数组 一开始想太复杂,好几次遇到都不知道怎么下手 ...//这是从xx题中选取的片段 class Shape{//这是一个抽象基类 ... }; ... int main() { int t; cin>>t; while(t--){ Shape *s[3];//...

    创建对象的指针数组

    一开始想太复杂,好几次遇到都不知道怎么下手

    ...//这是从xx题中选取的片段
    class Shape{//这是一个抽象基类
    ...
    };
    ...
    int main()
    {
        int t;
        cin>>t;
        while(t--){
            Shape *s[3];//要求创建对象的指针数组,可以这样创建
            ...
            s[0] = &c;//后续再相应赋值
            s[1] = &sq;//此处c、sq、rt是Shape的子类对象
            s[2] = &rt;
    		...
        }
        return 0;
    }
    

    需要注意的点,对象指针数组,数组中的元素都只是一个指针,需加*号,才能取到对象,期末机考又给自己挖坑了。

    template<class T>
    void compare(T* arr){
    	// 注意,在传入对象指针数组的情况下,此处会比较两个指针,而非比较两个对象
    	if(arr[0] < arr[1]){
    	//...
    	// 比较指针并不非调用对象的 < 重载函数,也不会调用类型转换重载函数
    	}
    	//...
    
    	// 比较对象的写法,也就是本来的目的
    	if(*arr[0] < *arr[1]){
    	//...
    	}
    }
    
    
    int main(){
    
    	Date* date[3];
    	date[0] = new Date();
    	date[1] = new Date();
    	//	...
    	compare(date);//此处传入了对象指针数组
    	return 0;
    }
    
    展开全文
  • //定义对象指针数组,并且初始化parray[0]和parray[1] parray[2]=&p3; //给parray[2]赋值 parray[3]=&p4; //给parray[3]赋值 for (int i=0; i; i++) { parray[i]->DisPoint(); //调用parray[i]所指向对象的成员函数...

    #include
    using namespace std;
    class Point
    {
    public :
    Point()
    {
    X=0;Y=0;
    }
    Point(int x,int y)
    {
    X=x;Y=y;
    }
    void DisPoint()
    {
    cout<<X<<","<<Y<<endl;
    }
    private : int X,Y;
    };
    int main(int argc, const char * argv[]) {
    Point p1,p2(2,3),p3(5,5),p4(9,8); //定义对象
    Point *parray[4]={&p1,&p2}; //定义对象指针数组,并且初始化parray[0]和parray[1]
    parray[2]=&p3; //给parray[2]赋值
    parray[3]=&p4; //给parray[3]赋值
    for (int i=0; i<4; i++) {
    parray[i]->DisPoint(); //调用parray[i]所指向对象的成员函数DisPoint()
    }
    return 0;
    }
    输出结果:
    0,0
    2,3
    5,5
    9,8
    Program ended with exit code: 0

    展开全文
  • 今天在研究infomap的源码的是否,发现里面定义了个Node的指针数组: Node **node = new Node*[Nnode]; for(i=0;i<Nnode;i++){ node[i]=new Node(i); degree[i]=0.0; } 对于Node **node = new Node*[Nnode]...

    今天在研究infomap的源码的是否,发现里面定义了个Node的指针数组:

    Node **node = new Node*[Nnode];
    for(i=0;i<Nnode;i++){
        node[i]=new Node(i);
        degree[i]=0.0;
    }

    对于Node **node = new Node*[Nnode],这一句比较好理解,就是在内存中申请了一片空间用于存放Nnode个指针,大小为Nnode*8 (假设指针类型的长度为8字节)。但是下面for循环进行赋值的时候不太理解:node[i]=new Node(i);为什么会这么写呢?

    new Node(i)不是得到一个Node的对象吗,怎么会是一个指针呢?

    • new创建类对象需要指针接收,一处初始化,多处使用//new出来的其实是一个指针,而不是具体对象,和java有区别
    • new创建类对象使用完需delete销毁
    • new创建对象直接使用堆空间,而局部不用new定义类对象则使用栈空间
    • new对象指针用途广泛,比如作为函数返回值、函数参数等
    • 频繁调用场合并不适合new,就像new申请和释放内存一样

    (1)使用new创建类对象:

    CTest* pTest = new CTest();

    delete pTest;

    pTest用来接收类对象指针。

    (2)不用new,直接使用类定义申明:

    CTest mTest;

    此种创建方式,创建之初就已经分配了内存空间,使用完后不需要手动释放,该类析构函数会自动执行。而new申请的对象,则只有调用到delete时再会执行析构函数,如果程序退出而没有执行delete则会造成内存泄漏。

    (3)类指针可以先行定义,但类指针只是个通用指针,在new之前并为该类对象分配任何内存空间。

    CTest* pTest = NULL;只是一个普通指针,没有经过new的操作分配具体空间,所以不用delete释放。

     

    1. 我们先看看如何动态定义一个char类型(基本类型int/float/double)的数组       

    const  int  n ;
    char *a = new char[n];

        new char[n] 表示在内存中(heap)分配了sizeof(char)*n字节的空间,并且返回一个指向所分配内存首地址的指针;   所以,在这里,定义了一个char类型的指针来指向这块内存空间。

    2   在看看如何动态定义一个char类型(基本类型int/float/double)的指针数组       

    const  int  n ;
    char **a = new char*[n];

       指针数组就是一个数组,只不过数组里面的元素是指针类型;而int类型的数组里面的元素是int类型。

      new char*[n]也表示在内存中(heap)分配了sizeof(char)*n字节的空间,并且返回一个指向所分配内存首地址的指针,但是,

      不同的是,这些内存里面放的是指针变量,即,存放的是地址。   因此,我们要定义一个二级指针来指向这块内存空间。详细理解,可以画出内存管理图.

     PS:在涉及到指针时,多想想内存分布及管理,必要时,可画出,可帮助理解。

    3   最后,如何动态定义一个 对象指针数组

    #include <iostream>
    
    using namespace std;
    class A
    {
    private:
        int i;
    public:
        A(int i)
        {
            this->i=i;
        }
        int getI(){
            return i;
        }
        void setI(int k){
            i=k;
        }
    };
    
    int main()
    {
        int n=10;
        A** a =new A*[n];
        cout<<"a的地址:"<<a<<endl;
        cout<<"sizeof(A): "<<sizeof(A)<<endl;
        for(int i=0; i<n; i++){
            a[i] = new A(i);
            cout<<"(*a["<<i<<"]).getI(): "<<(*a[i]).getI();//a[i]是指针,所以*a[i]代表A类的对象
            cout<<", a["<<i<<"]->getI(): "<<a[i]->getI();//a[i]是指针,所以a[i]->getI()调用该指针对应的对象的函数
            cout<<", &(*a["<<i<<"])"<<&(*a[i]);//A的对象所在的内存地址
            cout<<", a["<<i<<"] :"<<a[i]<<", &a["<<i<<"] :"<<&a[i]<<endl;//指针a[i]的值(内容)以及存放(指向)指针a[i]的地址。
        }
        for(int i=0;i<n;i++){
            delete a[i];
        }
        delete a;
        return 0;
    }
    

    a[i] = new A(i); 的含义:new A()表示定义一个A 对象,并在heap中分配内存空间,并返回一个指向该内存的指针(new返回的是对指针)。  并用a[i]指向他。

    以下图中a[5]为例,a[5]=new A(5);是两个步骤:new A(5)表示定义了一个A的对象(没名字,这一点很重要,这句话并不是说为a[5]分配一个存储空间,而是在heap内申请一片区域来保存A的一个对象,但是这个对象总得有个名字,或者handler吧,要不然你没法用啊),并在heap中给她分配了内存空间(从0x5fafd8开始到0x5fafe8的16个字节的空间),并返回一个指向该内存的指针a[5],a[5]的内容写的是0x5fafd8,而a[5]自己所在的位置是0x5fb834,它在指针数组的第6个位置,也就是它距离指针数组a的起始位置0x5fb820为4*6=24个字节。

    动态分配的内存(各个new A(i))都存放在堆上,而指针放在栈上(各a[i])。 如果要写程序验证的话,你在方法内部new一个对象,然后把对象的引用(指针)返回给上层函数,如果在栈上,方法返回后对象会释放,如果在堆上不会被释放,而且你在方法内部给堆对象赋值都还有效(后面我们给出了一个例子)。

    上面我们的示例代码中,(*a[i]).getI()和a[i]->getI()得到的值一样,又引出了另一个问题:C 语言结构体之点运算符( . )和箭头运算符( -> )的区别 :

    我们使用类的对象的时候,有时用点运算符( . ),时而是用箭头运算符( -> );那么这两者之间的使用有什么区别么?

    相同点:两者都是二元操作符,而且右边的操作数都是成员的名称(成员变量或者成员函数)。
    不同点:点运算符( . )的左边操作数是一个结果为对象的表达式;
                  箭头运算符( -> )的左边的操作数是一个指向对象的指针。

    继续聊堆和栈的问题:

    class CTest
    {
        public:
            int a;
    };
    class CBest
    {
        public:
            int b;
    };
    
    CTest* fun(CBest* pBest)
    {
       CTest* pTest = new CTest();
       pTest->a = pBest->b;
       return pTest;
    }
    
    int main()
    {
        CBest* pBest = new CBest();
        CTest* pRes= fun(pBest);
        if(pBest!=NULL){
            cout<<"pBest不为空"<<endl;
            delete pBest;
        }
        if(pRes!=NULL){
           cout<<"pRes不为空"<<endl;
           delete pRes ;
        }
        /*if(pTest!=NULL){//这一段必须注释掉,pTest只是一个局部变量,这里无法访问到,pTest是放在栈上的
            cout<<"pTest不为空"<<endl;
           delete pTest ;
        }*/
    
        return 0;
    }

    JAVA:
    A a = new A();
    为A对象创建了一个实例,但在内存中开辟了两块空间:一块空间在堆区,存放new A()这个对象;
    另一块空间在堆栈,也就是栈,存放a,a的值为new A()这个对象的内存地址。因为java在JVM中运行,
    所以a 描述的内存地址不一定是这个对象真实内存的地址。
     
    Object o; // 这是声明一个引用,它的类型是Object,他的值为null,还没有指向任何对象,该引用放在内存的栈区域中。
     
    o = new Object(); // new Object()句,实例化了一个对象,就是在堆中申请了一块连续空间用来存放该对象。
    = // 运算符,将引向o指向了对象。也就是说将栈中表示引用o的内存地址的内容改写成了Object对象在堆中的地址。
     
    C++:
    C++ 如果直接定义类,如classA a; a 存在栈上(也意味着复制了对象a在栈中),如果classA a = new classA就存在堆中。
    
    C++中:
    Student  student(20) ;  //这里student是引用 对象分配在 栈空间中,这里只是我的理解
    
    Student *student = new  Student(20);  //这里student是指针它本身在栈中,new Student(20)是分配在堆内存空间的
    new Student(20)是在堆空间里创建的实体,它与在数据段以及栈空间里创建的实体不同。尽管它们也是确确实实存在的实体,但是,我们看不见,也摸不着。所以必须用一个东西来表示它,这个就是指针或者引用了。这里我们使用student来指向堆中申请的这块区域,后面就可以用这个指针对这块区域进行访问了。

    参考:
    https://blog.csdn.net/ShenYuanLuo/article/details/51146140 

    https://blog.csdn.net/tham_/article/details/44906571

    https://zhidao.baidu.com/question/430058703.html

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

    千次阅读 2019-04-21 12:27:40
    typedef Student * PStudent; PStudent *stud;//Student **stud; stud=new PStudent[5];...每一维都是一个指针 for(int k=0;k<5;k++) stud[k]=new Student();//为每一维指针new一个类 代替: typedef Stu...
    typedef Student * PStudent;
    PStudent *stud;//Student **stud;
    stud=new PStudent[5];//stud=new Student *[5];每一维都是一个指针
    for(int k=0;k<5;k++)
        stud[k]=new Student();//为每一维指针new一个类

    代替:

    typedef Student *PStudent;
    PStudent stud[5];
    for(int k=0;k<5;k++)
        stud[k]=new Student();



    原文:https://blog.csdn.net/fengfeng0328/article/details/69870099 

    展开全文
  • 主要介绍了C++中用new创建二维数组和指针数组实例代码,非常不错,具有参考借鉴价值,需要的朋友参考下
  • 如果a是已经定义好的一个类,有如下定义语句:a *p[5],则当类对象数组指针p离开它的作用域时,系统自动调用类a的析构函数0次。 为什么是0次????
  • C++对象指针 指向对象的指针 在建立对象时,编译系统会为每一个对象分配一定的存储空间,以存放其成员。对象空间的起始地址就是对象的指针。可以定义一个指针变量,用来存放对象的指针。 如果有一个类: class ...
  • 如何动态定义一个 对象指针数组

    千次阅读 2013-12-12 09:45:09
    1 我们先看看如何动态定义一个char类型(基本类型int/float/double)的数组  const int n ;  char *a = new char[n];  new char[n] 表示在内存中(heap)分配了sizeof(char)*n字节的空间,并且返回一个指向所...
  • 对象数组对象指针

    2019-03-24 14:03:45
    类 ---- 对象数组对象指针学习。
  • C++对象指针数组与堆中对象数组

    千次阅读 2016-05-06 11:15:31
    /*堆中对象数组、对象指针数组*/ class stu { public: void set(int x){i = x + 6;} int get(){return i*i;}; private: int i; }; void main() { const int n = 1000; stu * p = new stu[n];
  • 1.对象指针可以指向新的对象名 2.箭头运算符 ->:用指针访问对象成员 Circle circle1; Circle * pCircle = &circle1;//定义了一个对象指针,指向一个对象 //对指针做点应用操作 cout << "The ...
  • 这里就不介绍什么是二级指针了,直接看程序领会吧!! typedef Student * PStudent; PStudent *stud;//Student **stud; stud=new PStudent[5];//stud=new Student *[5];每一维都是一个指针 for(int k=0;k stud[k]=...
  • C++之对象数组对象指针

    千次阅读 2018-10-23 19:07:59
    1.对象数组 是指每一个数组元素都是对象数组,也就是说,若一个类有若干个对象,我们把一系列的对象用一个数组来存放。对象数组的元素是对象,不仅具有数据成员,而且还有函数成员。 格式: 类名 数组名[下标...
  • QT中函数指针数组

    2020-08-14 17:21:49
    QT中函数指针数组自定义类函数定义函数指针数组使用 自定义类 class myclass{ typedef void (myclass::*Funs)(QJsonObject *jsonObject,void *para); /函数声明/ void fun1(QJsonObject *jsonObject,void *para); ...
  • 所谓对象数组是指每一个数组元素都是对象数组吗,也就是说,若一个类有若干个对象, 我们把这一系列的对象用一个数组存放。对象数组的元素是对象。不仅具有数据成员,而且还有函数成员。 定义一个一维数组的...
  • 自定义类的数组和指针数组是否调用析构函数
  • 编码情景是要动态分配个数不确定的非内嵌类型对象,把获取的对象指针都存在一个数组里面,留待其他地方使用. 定义指针 CBase** m_pMotion; 个人偏向于用new/delete关键字,当然也可以用malloc/free函数组合来进行内存...
  • 指针数组与函数指针

    千次阅读 2020-05-19 18:10:24
    上一篇写了指针的定义及基本使用,这章我们来看一下数组指针的使用。 指针数组和地址间的关系 在定义数组时,编译器必须分配基地址和足够的存储空间,以存储数组的所有元素。数组的基地址是在内存中存储数组的起始...
  • 指针对象数组的析构问题

    千次阅读 2016-04-11 10:40:56
    类中在对象执行完它的行为后,生命周期结束,一般会调用析构函数来回收该对象所拥有的资源,那么如果该对象是一个数组,我们应该注意一些什么呢: 先看下面一段代码: #include using namespace std; class father...
  • 数组指针和指针数组,从字面上区分的方法就是:本质看最后两个字。例如数组指针的本质就是一个指针,一个指向数组的指针;而指针数组的本质就是一个数组,一个成员都是指针的数组。 1.数组指针 1.1 基本概念 数组...
  • C++对象数组

    千次阅读 多人点赞 2019-09-24 08:24:49
    C++对象数组 一、对象数组 1.C++对象数组的定义:类名 数组名[元素个数] 例:Student stu[10]; 2.对象数组访问形式:数组名[下标].成员名; 例:stu[i].print(); 3.对象数组的初始化:对象数组的初始化通常也...
  • 指针数组理解

    千次阅读 2019-05-08 17:40:24
    指针数组的元素存放对象的地址。 说明形式为:类型 * 标识符 [ 表达式 ] ; 先让我们来看一个实例,它用到了一个由 3 个整数组成的数组: #include using namespace std; const int MAX = 3; i...
  • 以下是对C++中的指针数组与指向指针的指针进行了详细的介绍,需要的朋友可以过来参考下
  • 一个老师写的。 1 引言 2 指针与对象指针数组 3 成员函数指针的语法和应用 4 在STL中处理对象指针 。。。
  • C++声明指针数组

    2020-10-07 15:31:25
    我们可以创建整型数组,也可以创建指针数组,即 int *api[10]; 二、解释 为了弄清这个复杂的声明,我们假定它是一个表达式,并对它进行求值。下标引用的优先级高于间接访问,所以在这个表达式中,首先执行下标...
  • 指针访问数组元素 指针的运算本身就是适合对连续的数据进行处理,而数组正好满足这一要求。所以这一节研究如何使用指针访问数组元素。 首先我们举个例子 int a[10],*p;//定义一个数组和一个指针变量p p=a;//或者p=&...
  • 指针数组与数组指针   当我们在学习指针与数组时总会遇到两个令人容易混淆的概念:数组指针与指针数组。   在这里数组指针是指向数组的指针,其本质为指针指向的对象是数组。由于数组的形式多样所以数组指针的...
  • int main() { Box a[3]= { Box(), Box(15,18,20), Box(16,20,26) ...说明:主函数定义对象数组a[3],并将对象数组a的首地址赋值给指针变量P,通过指针变量P的移动,让指针P分别指向a[0], a[1], a[2]的地址。

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 415,217
精华内容 166,086
关键字:

对象指针数组