精华内容
下载资源
问答
  • 什么建立链表一定要用new指针,不用new什么不行……………………
  • Java中为什么用new来构造对象

    千次阅读 2019-08-11 15:09:40
    如果我们要创建一个Text的对象t1我们就会用到text中的构造函数,并且在构造函数的前面加上new运算符 new Text() 这个表达式构造了一个Text的对象并且初始化了a的值。 所以我们要想创建一个对象应该 Text...

    假设我们写了一个简单的类
    class Text{
    private int a;
    Text(){
    a=0;
    }
    public int getA(){
    return a;
    }

    如果我们要创建一个Text的对象t1我们就会用到text中的构造函数,并且在构造函数的前面加上new运算符
    new Text()
    这个表达式构造了一个Text的对象并且初始化了a的值。
    所以我们要想创建一个对象应该
    Text t1=new Text();

    那么我们为什么不用
    Text t1 来构造呢
    其实用Text t1来声明的变量并不是一个对象,而是一个对象变量。
    在对象和对象变量之间存在着很大的区别,如Text t1 // t1 doesn’t refer to any object
    定义了一个对象变量,他可以应用Text类型的对象,但是这个t1不是一个对象,不能把Text中的方法应用于这个变量中
    如 t1.getA() 将会产生编译错误
    要想使用类中的方法必须要初始化变量t1
    可以
    Text t1=new Text();
    也可以
    t1=t(t为之前创建的Text对象)

    展开全文
  • 如果new 一个对象,free去释放,会有什么问题? 587人阅读 收藏 版权声明:本文为博主原创文章,未经博主允许不得转载。 关于C++里面的NEW/DELETE和maclloc/free。 昨天面试的时候被问到这个问题,...

    如果new 一个对象,用free去释放,会有什么问题?

    587人阅读 收藏

    版权声明:本文为博主原创文章,未经博主允许不得转载。

    关于C++里面的NEW/DELETE和maclloc/free。
    昨天面试的时候被问到这个问题,如果new 一个对象,用free去释放,会有什么问题?
    一时被问到这个陌生,于是就感觉来说,应该会报错。因为new与FREE不是配对的内存操作API。
    后转念一想,delete也是清除分配的内存,free也是同样的功能,可能不会报错,再加上因为delete处理过程中比free多一步就是调用析构函数。所以说可能不报错,但没有对分配的对象作一些后续的析构清理动作。
    今天就想写几行代码试下是否是这样。
    先来看下在这段代码:
     
    #include <iostream>
    using namespace std;
    class nf {
    public:
         nf();
        ~nf();
    public:
           int * get();
           void set(int i);
    private:
           int * pi;
    };

    nf::nf()
     {
           cout << "nf construction" << endl;
           pi = new int(0);
            }
     nf::~nf()
    {
           cout << "nf destruction" << endl;
           delete pi;
            }
     int * nf::get()
    {
               return pi;
     }

    void nf::set(int i)
    {
            * pi = i;
    }
    int main()
    {
           nf* pnf = new nf();
           pnf->set(100);
           int *pp = pnf->get();
           cout << *pp << endl;
           //delete pnf;
           free(pnf);
           cout << *pp << endl;
           return 0;
    }

     上面这段代码里面定义了一个类。类里面有一个指针成员,为什么用指针成员是想把类的成员的内存通过new分配到堆上去。通过构造函数分配一块内存,然后通过析构函数去释放该内存。同时里面还定义了一个get()成员函数,返回该成员的指针。set()函数主要就是给成员指针所指的对象赋值。
     先来说一下正常的情况,正常情况下,通过new创建该类的一个对象,对象创建的时候会调用构造函数为成员指针申请一块内存,通过set()赋值后,该指针通过get()返回,再去通过指针读取到的值应该是set()里面的值。
     如果通过delete删除前面申请的对象,那么同样会调用析构函数,释放掉构造函数里面申请的内存, 那么如果再通过get()返回的指针去读取的话,会得到不确定的值。
     
    再来分析一下,如果用new创建对象,再用free去释放内存,结果会怎么样呢?
    根据定义:new()函数实际过程中做了两步操作,第一步是分配内存空间,第二步是调用类的构造函数;delete()也同样是两步,第一步是调用类的析构函数,第二步才是释放内存;而malloc()和free()仅仅是分配内存与释放内存操作;
    那么如果通过new分配的内存,再用free去释放,就会少一步调用析构函数的过程。同时,在构造函数里面申请的内存因为没有调用析构函数,所以该内存并没有释放,所以如果再输出该内存的值,那么应该还是原来设置的值100;

    展开全文
  • new是在堆上分配内存,它需要delete释放,否则会造成内存泄漏(使用的内存没有即时释放,造成内存的浪费) 而A a在右大括号执行后,会自动释放内存 如 int main() { A a;//定义了一个a对象 A *p=new A;//在堆上...

    说明:此处内容是在网上摘抄的,总结一下,为了以后查找方面。

    new是在堆上分配内存,它需要用delete释放,否则会造成内存泄漏(使用的内存没有即时释放,造成内存的浪费)
    
    而A a在右大括号执行后,会自动释放内存
    如
    int main()
    {
    A a;//定义了一个a对象
    A *p=new A;//在堆上定义了一个对象,它的指针保存在p里,注意,堆上定义的对象没有名字,必须用指针保存
    return 0;
    }//a到这里的时候,它占用的内存就会被回收 而p,除非调用delete p; 否则内存永远不会被回收,指针p丢弃后,那块内存没被释放,
    无法被再次使用,造成内存浪费
      
    下面给你详细介绍一下动态分配内存new关见字的使用方法,希望看了之后你能全现了解什么时候可以使用new以及怎样使用new,
    以下内容全面,简单易懂,是完全出自本人的学习总结,绝非复制。
    
    动态分配内存new关见字
    
    1. 全局对象和局部对象的生命期都是严格定义的,程序员不能以任何方式改变他们的生命期。但是有时候需要创建一些生命期能被程序员控制的
          对象,他的分配和释放可以根据程序运行中的操作来决定。这时就需要使用new操作符了。
    2. 动态分配内存,将从堆中分配内存,动态分配的存储区是在运行时确定的,动态分配的存储区可以随着需求而自动扩大.
    3. 局部变量一般存储在堆栈中,堆栈是先进后出的存储结构,而堆却不是.
    4. 在C++中使用new动态分配内存,delete释放以前new分配的内存.
    5. 使用new运算符系统将从空闲存储区中为对象分配内存,并返回一个指向该对象的指针即该对象的地址。new运算符的特点是:
           用new运算符分配的对象没有名字,对该对象的操作都要通过指针间接地完成操作。例如new int,就是从空闲存储区分配了一个int型对象,
           但没法对这个对象进行操作,只是从存储区分配了这么一个空间。语句int *p=new int表示从空闲存储区分配一个int对象并把这个对象的
           地址赋给p,现在p就是用new分配的int对象的地址,而*p就是那里的值。语句int i;int*p=&i;和int *p=new int都是将int变量的地址赋给
           了指针,但不同的是前句可以用名称i和*p来访问该int型变量,而后句则只能用*p来访问该变量,也就是说p指向的内存没有名称。
    6. 动态创建数组:int *p=new int [11];创建动态数组时必须有[]方括号,且里面要有创建的维数,但该数组的第一维可以是一个复杂的
           表达式。访问地址中的内容的方法为*p访问数组中的第一个元素,p[1]该问第二个元素,以此类推。创建二组数组的例子:
           int (*p)[102]=new int [4][102]。
    7. 动态创建对象的初始化:int *p=new int(102)该语句表明由p指向的新创建你对象被初始化为102。动态创建对象的初始化方式为在类型名
          后面用一对括号来被始化。
    8. 动态创建对象的默认初始化:方式为在类型名后面跟一对空的圆括号初始化, 
          int *p=new int (); int *ps=new string(); cls *pc=new cls();
          第一条语句把对象的值初始化为0,第二条语句对于提供了默认构造函数的string类,不论程序是要明确的不初始化,还是要求进行值初始化
          都会调用默认构造函数初始化该对象。而对于内置类型或没有默认构造函数的类型,则采用不同的初始化方式就会有显著不同的差别。
          例如:int *p=new int; int *p=new int();第一条语句没有被初始化,而第二条被初始化为0。
    9. 用new动态创建的数组不能被初始化,不能创建初始化值集。
    10.耗尽内存:如果程序用完了所有可用的内存,new表达式就有可能失败。如果new表达式无法获得要需要的内存空间,
           系统将会抛出名为bad_alloc异常。
    11.可以在一个函数内使用new运算符分配内存,而在另一个函数中使用delete释放内存空间.delete只能用于释放前次使用new分配的空间,
           不要使用delete来释放不是new分配的内存,不要使用delete释放相同的内存两次,应使用delete []来释放动态数组,例如:
           int *p=new int [10];delete [] p;删除数组必须要有[]方括号。delete不一定要用于new的指针,
           例如int *p=new int ; int *x=p; delete x;将是合法的.如果指针的值为0,则在其上作delete操作是合法的,但没有任何意义。
    12.悬垂指针:执行delete p后只是把p所指向的地址的内容给释放掉了,并没有删掉指针p本身,还可以将p重新指向到另一个新的内存块,
           因此p还指向原来他指向的对象的地址,然而p所指向的内容却已经被释放了,因此p不再有效而变得没有定义了。这样的指针称为悬垂指针。
           悬垂指针往往导致程序错误而且很难检测出来。
    13.静态联编:如果通过声明来创建数组,则在程序被编译时为他分配内存空间,不管程序是否使用数组,数组都在那里,占用了内存。
           在编译时给数组分配内存被称为静态联编。意味着数组是在编译时加入到程序中的。但使用new时,如果在运行阶段需要数组,则创建他,
           如果不需要,则不创建,还可以在程序运行时选择数组的长度,这被称为动态联编。意味着数组是在程序运行时创建的,这种数组叫做
           动态数组,使用静态联编时必须在编写程序的时候指定数组的长度,使用动态联编时,程序将在运行时确定数组的长度。
    14.const常量对象的动态分配和回收:与其他常量一样,动态创建的const对象必须在创建时初始化,并且一经初始化,其值不能再修改。
           例如:const int *p= new const int(111);删除方法为:delete p;尽管程序员不能修改const对象的值,但可以撤消对象本身。
    15.注意:不能在空闲存储区上创建内置类型元素(除类数组string外)的const数组。因为我们不能初始化用new创建的内置类型数组的元素。
          如const int *p=new const int [11];将是错误的。
    16.注意:如果用new分配了资源,而没有用delete释放该资源的话,那么用new分配的资源将一指被占用。
    17.常见错误:如果对某个指针动态分配了内存,又把另一个变量的地址付给这个指针,这时这个指针就指向了一个静态地址,
           而不是原先的动态地址。如果再用delete删掉这个指针时就会出错,因为这时这个指针是指向静态地址的,不能用delete删除一个指向
           静态地址的指针。比如int *p =new int(1),这时指针p指向一个动态内存可以对他进行delete删除,但如果再执行语句int a=2; p=&a;
           这时就改变了指针指向的内容,使原先指向的动态内存地址变成了指向现在的静态内存地址,如果这时对指针p进行delete操作就会出错,
           因为你在对一个静态指针静行删除,而delete只能删除动态指针。
    例:动态分配对象new
    class hyong
    {public:int a,b,c;   hyong (){a=b=c=0;}   hyong(int i){a=b=c=i;}   ~hyong(){cout<<"xigou"<<"/n";}  };
    int main()
    { hyong *p=new hyong;   hyong *p1=new hyong(); cout<<p->a<<p1->a<<"/n"; //输出两个0,都调用默认构造函数初始化指针。
      int *p2=new int;      int *p3=new int();      int *p4=new int(1); //new分配内存的初始化方式。
        对于类置类型来说p2没有被初始化得到的是一个随机值,p3被初始化为0,p4被初始化为1。
      cout<<*p2<<"/n"<<*p3<<"/n"<<*p4<<"/n";  //输出一个随机值,一个0,一个1
       int i=10;  delete p4;  cout<<*p4<<"/n"; //p4现在是悬垂指针,delete只是释放掉了指针p4所指向地址的内容,
        但指针p4仍然指向原来的地址,但没有内容,指针p4仍然可以再指向其他地址。
      p4=&i; cout<<*p4<<"/n"; //可以对悬垂指针p4重新赋地址。
      const int *p5=new int; const int *p6=new int(4)  ;cout<<*p5<<*p6<<"/n";//输出一个随机值和4,const常量必须在声明时初始化。
      int *p7=new int[2];   p7[0]=5;p7[1]=6;    cout<<p7[0]<<p7[1]<<"/n";//定义动态数组,动态数组不能在声明时初始化。
      //const int *p8=new int[2];  //错误,因为动态数组不能在声明时初始化,而const又必须要求在声明时初始化,发生冲突,出错。
      delete p1;      delete p;    
      //delete p,p1;   //注意,如果使用该语句将则只调用一次析构函数。
      delete p2,p3,p4,p5,p6;    delete [] p7; 
      //int *p8=new int(9); int a=8;  p8=&a; delete p8;  //错误,现在的指针p8重新指向了一个静态的地址,
       用delete删掉一个静态地址将发生错误。
      } 
        
    A为一个类,当在同一个类中用A a,如果在不同的类中用new A 。
    展开全文
  • 关于C++里面的NEW/DELETE和maclloc/free。 如果new 一个对象,free去释放,会有什么问题?
    关于C++里面的NEW/DELETE和maclloc/free。

    昨天面试的时候被问到这个问题,如果new 一个对象,用free去释放,会有什么问题?

    一时被问到这个陌生,于是就感觉来说,应该会报错。因为new与FREE不是配对的内存操作API。
    后转念一想,delete也是清除分配的内存,free也是同样的功能,可能不会报错,再加上因为delete处理过程中比free多一步就是调用析构函数。所以说可能不报错,但没有对分配的对象作一些后续的析构清理动作。

    今天就想写几行代码试下是否是这样。
    先来看下在这段代码:
     
     #include <iostream>
     using namespace std;
     class nf{
       public:
         nf();
         ~nf();
       public:
         int * get();
         void set(int i);
         private:
         int * pi;
      };
     
      nf::nf()
      {
          cout<<"nf construction"<<endl;
          pi = new int(0);
      }
      
      nf::~nf()
      {
          cout<<"nf destruction"<<endl;
          delete pi;
      }
      
      int * nf::get()
      {
          return pi;
      }
      
      void nf::set(int i)
      {
          *pi = i;
      }

     
      上面这段代码里面定义了一个类。类里面有一个指针成员,为什么用指针成员是想把类的成员的内存通过new分配到堆上去。通过构造函数分配一块内存,然后通过析构函数去释放该内存。同时里面还定义了一个get()成员函数,返回该成员的指针。set()函数主要就是给成员指针所指的对象赋值。
     
      先来说一下正常的情况,正常情况下,通过new创建该类的一个对象,对象创建的时候会调用构造函数为成员指针申请一块内存,通过set()赋值后,该指针通过get()返回,再去通过指针读取到的值应该是set()里面的值。
      如果通过delete删除前面申请的对象,那么同样会调用析构函数,释放掉构造函数里面申请的内存,那么如果再通过get()返回的指针去读取的话,那么结果应该是0,因为被初始化了。
      通过以上分析,来查看下面的main()调用:
      int main(int argc,char ** argv)
      {
          nf * pnf = new nf();
      
          pnf->set(100);
          int * pp = pnf->get();
          cout<<*pp<<endl;
          delete pnf;
          //free(pnf);
      
          cout<<*pp<<endl;
          return 0;
      }



    编译:
    g++ -o m m.cpp
    运行:
    ./m
    结果:
    [ter]$ ./m                
    nf construction
    100
    nf destruction

    如上分析所同。

    再来分析一下,如果用new创建对象,再用free去释放内存,结果会怎么样呢?
    根据定义:new()函数实际过程中做了两步操作,第一步是分配内存空间,第二步是调用类的构造函数;delete()也同样是两步,第一步是调用类的析构函数,第二步才是释放内存;而malloc()和free()仅仅是分配内存与释放内存操作;
    那么如果通过new分配的内存,再用free去释放,就会少一步调用析构函数的过程。同时,在构造函数里面申请的内存因为没有调用析构函数,所以该内存并没有释放,所以如果再输出该内存的值,那么应该还是原来设置的值100;
    代码调用如下:
      int main(int argc,char ** argv)
      {
          nf * pnf = new nf();
      
          pnf->set(100);
          int * pp = pnf->get();
          cout<<*pp<<endl;
          //delete pnf;
          free(pnf);
      
          cout<<*pp<<endl;
          return 0;
      }


      编译:
      g++ -o m m.cpp
      运行:
      ./m
      结果:
      nf construction
      100
      100
     
      如上面分析所同。

    经过上面的事情,还是说明那个同样的道理,不在乎你经历的事情的多少,而在乎你有没有对事情进行思考。不管碰到什么问题,都通过已有的基础知识的基本定义进行思考分析,就算是没有经历过,没有碰到过的事情,结果也是可能分析出来的。当然思考完了,后续如果有机会还是动手试验下比较好。
    展开全文
  • +new Date是什么意思?

    万次阅读 2016-12-01 14:09:36
    JavaScript中可以在某个元素使用 ‘+’ 号,这个操作是将该元素转换秤Number类型,如果转换失败,那么将得到 NaN。 所以 +new Date 将会调用 Date.prototype 上的 valueOf 方法,而根据 MDN ,Date.prototype...
  • 1. new分为两步 a、内存分配 调用相应的operator new( )分配内存 b、构造函数 调用相应的构造函数   实验代码: 1. class T{ 2. public: 3. T(){ 4. cout &amp;amp;lt;&amp;amp;lt; &amp;...
  • link的问题,为什么new {x, row=i++ }后面要写等于,前面就不要写?
  • VC#中接口也能new么?new一个方法是什么意思?new和override的区别
  • mfc 里addnew()向mysql表中添加记录时有时在前面,有时在后面,求解啊!!
  • 如何必须用new来实例化function

    千次阅读 2017-01-11 09:30:58
    我们知道使用function可以用new来实例化,那么为啥要用new?以及在代码中我们能否控制队友写代码时必须写new呢? 回顾 - 前面我们做了这样的代码结构var God = { //... }; //这是母体,用来加工和扩展业务对象var ...
  • 参考博文: ... ...   new和delete是C++中的表达式,用于创建一个新的对象。它们是对堆中的内存进行申请和释放,而且这两个都是不能被重载的。要实现不同的内存分配行为,需要...
  • unity3d这个脚本在这个场景(A)中,不过我切换到别的场景(B)中,前面场景(A)的staic、new什么还存在。当我切换回来A时static定的变量值没变,如果清除了应该归0呀。切换场景不是这个场景就结束了吗,应该消除...
  • 完全搞懂js 中的new()到底做了什么?

    万次阅读 多人点赞 2019-08-10 18:43:26
    今天面试,总体还可以,其中有一个问题我回答的很支支吾吾,就是js在new()过程中到底做了什么?(我居然从堆和栈的角度来回答的,面试官想听的根本不是这个,错的很离谱啊)下面便来总结一下吧: 要创建 Person 的...
  • new的数据能free吗?

    千次阅读 2017-06-22 17:24:45
    我的标题是我今天看到的一个面试题,...凭自己的直觉吧,猜了个“不可以”的答案,虽然对了,但我不知道为什么。于是 我就查查资料了: 不可以,new对应delete不可以张冠李戴。 malloc/free,new/delete必需
  • 它是类级别的静态方法,是在创建实例对象执行,如果自定义类中没有重写该方法,则Python自动调用父类的方法,当所有父类也没有重写定义该方法时,则直接调用object类的__new__方法。如果该方法不能正确返回,可能...
  • 浅谈 C++ 中的 new/delete 和 new[]/delete[]

    万次阅读 多人点赞 2014-03-17 22:49:32
    在 C++ 中,你也许经常使用 new 和 delete 来动态申请和释放内存,但你可曾想过以下问题呢? ...为什么 new [] 出来的数组有时可以 delete 释放有时又不行?… 如果你对这些问题都有疑问的话,
  • C++ 内存分配(new,operator new)详解

    万次阅读 多人点赞 2013-07-09 14:55:55
    讲述C++ new关键字和operator new, placement new之间的种种关联,new的底层实现,以及operator new的重载和一些在内存池,STL中的应用。
  • 而在变量上 new要写在public前面,方法上 new写在public 后面 。 1、public new public new void Method2() { Console.WriteLine("Derived - Method2"); } 当基类和派生类都有Method2()时,派生类的对象会...
  • 用new来给一个类的对象分配空间,和使用类名称来定义一个类的对象,有什么区别?难道区别只是new的返回值是个指针,而对象定义得到的是变量名么?或者是在存储空间上不同?有什么不同呢?具体什么时候使用哪个方法呢...
  • 来源:https://segmentfault.com/q/1010000008666596 https://zhidao.baidu.com/question/361146175916081012.html
  • C++——new和delete之后发生了什么

    千次阅读 2017-07-16 14:19:53
    总有一些事情比其他事情更基本一点,现在我来谈谈当我们new和delete之后到底发生了什么。C++中的五种内存在C++中内存分为五个区:堆、栈、自由存储区、全局/静态存储区和常量存储区。 堆区:用户使
  • Shift+Alt+L 比如我输入new TextView(this);按这个快捷键能自动生成TextView textView=new TextView(this);
  • 在 C++ 中,你也许经常使用 new 和 delete 来动态申请和释放内存,但你可曾想过以下问题呢?...为什么 new [] 出来的数组有时可以 delete 释放有时又不行?… 如果你对这些问题都有疑问的话,
  • 凭自己的直觉吧,猜了个“不可以”的答案,虽然对了,但我不知道为什么。于是 我就查查资料了: 不可以,new对应delete不可以张冠李戴。 malloc/free,new/delete必需配对使用。 malloc与free是c++、c语言的标准...
  •  java开发中有时会需要获取当前时间的一(几)天或者后一(几)天 代码:  Date date=new Date();//取时间 Calendar calendar = new GregorianCalendar(); calendar.setTime(date); calendar.add
  • 习题 8.19(2)写一函数free,将前面用new函数占用的空间释放。free(p)表示将p(地址)指向的单元以后的内存段释放。 代码块: #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; char *neww...
  • override与new关键字

    千次阅读 2013-11-21 22:18:43
    override:重写,在...new在子类方法,表示该方法与基类完全独立,属于子类本身。   基类代码: class VirtualClass { public virtual void VirtualMethod() { Console.WriteLine("farther's virtual
  • 什么对象被new 以后在执行dup操作?

    千次阅读 2008-05-05 14:59:00
    什么对象被new 以后在执行dup操作?今天有个朋友问我,为什么一个new一个对象的指令在new后面紧跟的是dup操作?他说搜了可能找到的搜索引擎都找不到答案,包括翻了>这本书也没有任何说明.我们先来看看为dup指令的作用,...
  • new的初始化

    万次阅读 2017-07-27 22:32:37
    有如下C++代码:int* buffer = new int[512];在默认情况下,new是不会对分配的int进行初始化的。要想使分配的int初始化为0,需要显式地调用其初始化函数:int* buffer = new int(); // 分配的一个int初始化为0 int* ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 2,660,636
精华内容 1,064,254
关键字:

new前面用什么