Why should I use a pointer rather than the object itself

Question

I m coming from a Java background and have started working with objects in C    But one thing that occurred to me is that people often use pointers to objects rather than the objects themselves  for example this declaration   Object  myObject   new Object    rather than   Object myObject    Or instead of using a function  let s say testFunc    like this   myObject testFunc      we have to write   myObject- gt testFunc      But I can t figure out why should we do it this way  I would assume it has to do with efficiency and speed since we get direct access to the memory address  Am I right

User · Answer

This is has been discussed at length  but in Java everything is a pointer  It makes no distinction between stack and heap allocations  all objects are allocated on the heap   so you don t realize you re using pointers  In C    you can mix the two  depending on your memory requirements  Performance and memory usage is more deterministic in C    duh

User · Answer

Another good reason to use pointers would be for forward declarations  In a large enough project they can really speed up compile time

User · Answer

Well the main question is Why should I use a pointer rather than the object itself  And my answer  you should  almost  never use pointer instead of object  because C   has references  it is safer then pointers and guarantees the same performance as pointers   Another thing you mentioned in your question   Object  myObject   new Object    How does it work  It creates pointer of Object type  allocates memory to fit one object and calls default constructor  sounds good  right  But actually it isn t so good  if you dynamically allocated memory  used keyword new   you also have to free memory manually  that means in code you should have   delete myObject    This calls destructor and frees memory  looks easy  however in big projects may be difficult to detect if one thread freed memory or not  but for that purpose you can try shared pointers  these slightly decreases performance  but it is much easier to work with them     And now some introduction is over and go back to question   You can use pointers instead of objects to get better performance while transferring data between function   Take a look  you have std  string  it is also object  and it contains really much data  for example big XML  now you need to parse it  but for that you have function void foo      which can be declarated in different ways    void foo std  string xml   In this case you will copy all data from your variable to function stack  it takes some time  so your performance will be low  void foo std  string  xml   In this case you will pass pointer to object  same speed as passing size t variable  however this declaration has error prone  because you can pass NULL pointer or invalid pointer  Pointers usually used in C because it doesn t have references  void foo std  string amp  xml   Here you pass reference  basically it is the same as passing pointer  but compiler does some stuff and you cannot pass invalid reference  actually it is possible to create situation with invalid reference  but it is tricking compiler   void foo const std  string  xml   Here is the same as second  just pointer value cannot be changed  void foo const std  string amp  xml   Here is the same as third  but object value cannot be changed    What more I want to mention  you can use these 5 ways to pass data no matter which allocation way you have chosen  with new or regular      Another thing to mention  when you create object in regular way  you allocate memory in stack  but while you create it with new you allocate heap  It is much faster to allocate stack  but it is kind a small for really big arrays of data  so if you need big object you should use heap  because you may get stack overflow  but usually this issue is solved using STL containers and remember std  string is also container  some guys forgot it

User · Answer

Preface  Java is nothing like C    contrary to hype  The Java hype machine would like you to believe that because Java has C   like syntax  that the languages are similar  Nothing can be further from the truth  This misinformation is part of the reason why Java programmers go to C   and use Java-like syntax without understanding the implications of their code   Onwards we go     But I can t figure out why should we do it this way  I would assume it   has to do with efficiency and speed since we get direct access to the   memory address  Am I right    To the contrary  actually  The heap is much slower than the stack  because the stack is very simple compared to the heap  Automatic storage variables  aka stack variables  have their destructors called once they go out of scope  For example         std  string s       s is destroyed here   On the other hand  if you use a pointer dynamically allocated  its destructor must be called manually  delete calls this destructor for you         std  string  s   new std  string    delete s     destructor called   This has nothing to do with the new syntax prevalent in C  and Java  They are used for completely different purposes    Benefits of dynamic allocation     1  You don t have to know the size of the array in advance   One of the first problems many C   programmers run into is that when they are accepting arbitrary input from users  you can only allocate a fixed size for a stack variable  You cannot change the size of arrays either  For example   char buffer 100   std  cin  gt  gt  buffer     bad input   buffer overflow   Of course  if you used an std  string instead  std  string internally resizes itself so that shouldn t be a problem  But essentially the solution to this problem is dynamic allocation  You can allocate dynamic memory based on the input of the user  for example   int   pointer  std  cout  lt  lt   How many items do you need    std  cin  gt  gt  n  pointer   new int n        Side note  One mistake many beginners make is the usage of   variable length arrays  This is a GNU extension and also one in Clang   because they mirror many of GCC s extensions  So the following    int arr n  should not be relied on    Because the heap is much bigger than the stack  one can arbitrarily allocate reallocate as much memory as he she needs  whereas the stack has a limitation       2  Arrays are not pointers   How is this a benefit you ask  The answer will become clear once you understand the confusion myth behind arrays and pointers  It is commonly assumed that they are the same  but they are not  This myth comes from the fact that pointers can be subscripted just like arrays and because of arrays decay to pointers at the top level in a function declaration  However  once an array decays to a pointer  the pointer loses its sizeof information  So sizeof pointer  will give the size of the pointer in bytes  which is usually 8 bytes on a 64-bit system    You cannot assign to arrays  only initialize them  For example   int arr 5     1  2  3  4  5      initialization  int arr      1  2  3  4  5      The standard dictates that the size of the array                                 be given by the amount of members in the initializer   arr     1  2  3  4  5       ERROR   On the other hand  you can do whatever you want with pointers  Unfortunately  because the distinction between pointers and arrays are hand-waved in Java and C   beginners don t understand the difference       3  Polymorphism   Java and C  have facilities that allow you to treat objects as another  for example using the as keyword  So if somebody wanted to treat an Entity object as a Player object  one could do Player player   Entity as Player  This is very useful if you intend to call functions on a homogeneous container that should only apply to a specific type  The functionality can be achieved in a similar fashion below   std  vector lt Base  gt  vector  vector push back  amp square   vector push back  amp triangle   for  auto amp  e   vector         auto test   dynamic cast lt Triangle  gt  e      I only care about triangles      if   test     not a triangle         e GenericFunction         else         e TriangleOnlyMagic        So say if only Triangles had a Rotate function  it would be a compiler error if you tried to call it on all objects of the class  Using dynamic cast  you can simulate the as keyword  To be clear  if a cast fails  it returns an invalid pointer  So  test is essentially a shorthand for checking if test is NULL or an invalid pointer  which means the cast failed   Benefits of automatic variables  After seeing all the great things dynamic allocation can do  you re probably wondering why wouldn t anyone NOT use dynamic allocation all the time  I already told you one reason  the heap is slow  And if you don t need all that memory  you shouldn t abuse it  So here are some disadvantages in no particular order    It is error-prone  Manual memory allocation is dangerous and you are prone to leaks  If you are not proficient at using the debugger or valgrind  a memory leak tool   you may pull your hair out of your head  Luckily RAII idioms and smart pointers alleviate this a bit  but you must be familiar with practices such as The Rule Of Three and The Rule Of Five  It is a lot of information to take in  and beginners who either don t know or don t care will fall into this trap  It is not necessary  Unlike Java and C  where it is idiomatic to use the new keyword everywhere  in C    you should only use it if you need to  The common phrase goes  everything looks like a nail if you have a hammer  Whereas beginners who start with C   are scared of pointers and learn to use stack variables by habit  Java and C  programmers start by using pointers without understanding it  That is literally stepping off on the wrong foot  You must abandon everything you know because the syntax is one thing  learning the language is another       1   N RVO - Aka   Named  Return Value Optimization   One optimization many compilers make are things called elision and return value optimization  These things can obviate unnecessary copys which is useful for objects that are very large  such as a vector containing many elements  Normally the common practice is to use pointers to transfer ownership rather than copying the large objects to move them around  This has lead to the inception of move semantics and smart pointers   If you are using pointers   N RVO does NOT occur  It is more beneficial and less error-prone to take advantage of  N RVO rather than returning or passing pointers if you are worried about optimization  Error leaks can happen if the caller of a function is responsible for deleteing a dynamically allocated object and such  It can be difficult to track the ownership of an object if pointers are being passed around like a hot potato  Just use stack variables because it is simpler and better

User · Answer

One reason for using pointers is to interface with C functions  Another reason is to save memory  for example  instead of passing an object which contains a lot of data and has a processor-intensive copy-constructor to a function  just pass a pointer to the object  saving memory and speed especially if you re in a loop  however a reference would be better in that case  unless you re using an C-style array

User · Answer

The key strength of object pointers in C   is allowing for polymorphic arrays and maps of pointers of the same superclass   It allows  for example  to put parakeets  chickens  robins  ostriches  etc  in an array of Bird  Additionally  dynamically allocated objects are more flexible  and can use HEAP memory whereas a locally allocated object will use the STACK memory unless it is static   Having large objects on the stack  especially when using recursion  will undoubtedly lead to stack overflow

User · Answer

Technically it is a memory allocation issue  however here are two more practical aspects of this  It has to do with two things  1  Scope  when you define an object without a pointer you will no longer be able to access it after the code block it is defined in  whereas if you define a pointer with  new  then you can access it from anywhere you have a pointer to this memory until you call  delete  on the same pointer  2  If you want to pass arguments to a function you want to pass a pointer or a reference in order to be more efficient  When you pass an Object then the object is copied  if this is an object that uses a lot of memory this might be CPU consuming  e g  you copy a vector full of data   When you pass a pointer all you pass is one int  depending of implementation but most of them are one int    Other than that you need to understand that  new  allocates memory on the heap that needs to be freed at some point  When you don t have to use  new  I suggest you use a regular object definition  on the stack

User · Answer

Necessity is the mother of invention   The most of important difference that I would like to point out is the outcome of my own experience of coding  Sometimes you need to pass objects to functions  In that case  if your object is of a very big class then passing it as an object will copy its state   which you might not want   AND CAN BE BIG OVERHEAD  thus resulting in an overhead of copying object  while pointer is fixed 4-byte size  assuming 32 bit   Other reasons are already mentioned above

User · Answer

Let s say that you have class A that contain class B When you want to call some function of class B outside class A you will simply obtain a pointer to this class and you can do whatever you want and it will also change context of class B in your class A  But be careful with dynamic object

User · Answer

I will include one important use case of pointer  When you are storing some object in the base class  but it could be polymorphic   Class Base1       Class Derived1   public Base1        Class Base2     Base  bObj    virtual void createMemerObects     0      Class Derived2     virtual void createMemerObects         bObj   new Derived1             So in this case you can t declare bObj as an direct object  you have to have pointer

User · Answer

In areas where memory utilization is at its premium   pointers comes handy  For example consider a minimax algorithm  where thousands of nodes will be generated using recursive routine  and later use them to evaluate the next best move in game  ability to deallocate or reset  as in smart pointers  significantly reduces memory consumption  Whereas the non-pointer variable continues to occupy space till it s  recursive call returns a value

User · Answer

There are many benefits of using pointers to object -    Efficiency  as you already pointed out   Passing objects to functions mean creating new copies of object   Working with objects from third party libraries  If your object belongs to a third party code and the authors intend the usage of their objects through pointers only  no copy constructors etc  the only way you can pass around this object is using pointers  Passing by value may cause issues   Deep copy   shallow copy issues   if the object owns a resource and you want that the ownership should not be sahred with other objects

User · Answer

A pointer directly references the memory location of an object  Java has nothing like this  Java has references that reference the location of object through hash tables  You cannot do anything like pointer arithmetic in Java with these references   To answer your question  it s just your preference  I prefer using the Java-like syntax

User · Answer

There are many use cases for pointers    Polymorphic behavior  For polymorphic types  pointers  or references  are used to avoid slicing   class Base          class Derived   public Base           void fun Base b          void gun Base  b          void hun Base amp  b           Derived d  fun d         oops  all Derived parts silently  sliced  off gun  amp d        OK  a Derived object IS-A Base object hun d         also OK  reference also doesn t slice   Reference semantics and avoiding copying  For non-polymorphic types  a pointer  or a reference  will avoid copying a potentially expensive object  Base b  fun b       copies b  potentially expensive  gun  amp b      takes a pointer to b  no copying hun b       regular syntax  behaves as a pointer   Note that C  11 has move semantics that can avoid many copies of expensive objects into function argument and as return values  But using a pointer will definitely avoid those and will allow multiple pointers on the same object  whereas an object can only be moved from once    Resource acquisition  Creating a pointer to a resource using the new operator is an anti-pattern in modern C    Use a special resource class  one of the Standard containers  or a smart pointer  std  unique ptr lt  gt  or std  shared ptr lt  gt    Consider            auto b   new Base                   oops  if an exception is thrown  destructor not called      delete b      vs          auto b   std  make unique lt Base gt                      OK  now exception safe     A raw pointer should only be used as a  view  and not in any way involved in ownership  be it through direct creation or implicitly through return values  See also this Q amp A from the C   FAQ   More fine-grained life-time control Every time a shared pointer is being copied  e g  as a function argument  the resource it points to is being kept alive  Regular objects  not created by new  either directly by you or inside a resource class  are destroyed when going out of scope

User · Answer

C   gives you three ways to pass an object  by pointer  by reference  and by value  Java limits you with the latter one  the only exception is primitive types like int  boolean etc   If you want to use C   not just like a weird toy  then you d better get to know the difference between these three ways   Java pretends that there is no such problem as  who and when should destroy this    The answer is  The Garbage Collector  Great and Awful  Nevertheless  it can t provide 100  protection against memory leaks  yes  java can leak memory   Actually  GC gives you a false sense of safety  The bigger your SUV  the longer your way to the evacuator   C   leaves you face-to-face with object s lifecycle management  Well  there are means to deal with that  smart pointers family  QObject in Qt and so on   but none of them can be used in  fire and forget  manner like GC  you should always keep in mind memory handling  Not only should you care about destroying an object  you also have to avoid destroying the same object more than once   Not scared yet  Ok  cyclic references - handle them yourself  human  And remember  kill each object precisely once  we C   runtimes don t like those who mess with corpses  leave dead ones alone   So  back to your question   When you pass your object around by value  not by pointer or by reference  you copy the object  the whole object  whether it s a couple of bytes or a huge database dump - you re smart enough to care to avoid latter  aren t you   every time you do      And to access the object s members  you use      dot    When you pass your object by pointer  you copy just a few bytes  4 on 32-bit systems  8 on 64-bit ones   namely - the address of this object  And to show this to everyone  you use this fancy  -   operator when you access the members  Or you can use the combination of     and       When you use references  then you get the pointer that pretends to be a value  It s a pointer  but you access the members through       And  to blow your mind one more time  when you declare several variables separated by commas  then  watch the hands     Type is given to everyone Value pointer reference modifier is individual   Example   struct MyStruct       int  someIntPointer  someInt    here comes the surprise     MyStruct  somePointer      MyStruct  amp someReference      MyStruct s1    we allocated an object on stack  not in heap  s1 someInt   1    someInt is of type  int   not  int   - value pointer modifier is individual s1 someIntPointer    amp s1 someInt   s1 someIntPointer   2    now s1 someInt has value  2  s1 somePointer    amp s1  s1 someReference   s1    note there is no   amp   operator  reference tries to look like value s1 somePointer- gt someInt   3    now s1 someInt has value  3    s1 somePointer  someInt   3    same as above line  s1 somePointer- gt someIntPointer   4    now s1 someInt has value  4   s1 someReference someInt   5    now s1 someInt has value  5                                  although someReference is not value  it s members are accessed through      MyStruct s2   s1     NO WAY  the compiler will say  Go define your     operator and come back     OK  assume we have     defined in MyStruct  s2 someInt   0    s2 someInt    0  but s1 someInt is still 5 - it s two completely different objects  not the references to the same one

User · Answer

There are many excellent answers to this question  including the important use cases of forward declarations  polymorphism etc  but I feel a part of the  quot soul quot  of your question is not answered - namely what the different syntaxes mean across Java and C    Let s examine the situation comparing the two languages  Java  Object object1   new Object      A new object is allocated by Java Object object2   new Object      Another new object is allocated by Java  object1   object2     object1 now points to the object originally allocated for object2   The object originally allocated for object1 is now  quot dead quot  - nothing points to it  so it   will be reclaimed by the Garbage Collector    If either object1 or object2 is changed  the change will be reflected to the other  The closest equivalent to this  is  C    Object   object1   new Object      A new object is allocated on the heap Object   object2   new Object      Another new object is allocated on the heap delete object1    Since C   does not have a garbage collector  if we don t do that  the next line would    cause a  quot memory leak quot   i e  a piece of claimed memory that the app cannot use    and that we have no way to reclaim     object1   object2    Same as Java  object1 points to object2   Let s see the alternative C   way  Object object1    A new object is allocated on the STACK Object object2    Another new object is allocated on the STACK object1   object2        This is different  The CONTENTS of object2 are COPIED onto object1    using the  quot copy assignment operator quot   the definition of operator      But  the two objects are still different  Change one  the other remains unchanged    Also  the objects get automatically destroyed once the function returns     The best way to think of it is that -- more or less -- Java  implicitly  handles pointers to objects  while C   may handle either pointers to objects  or the objects themselves  There are exceptions to this -- for example  if you declare Java  quot primitive quot  types  they are actual values that are copied  and not pointers  So  Java  int object1    An integer is allocated on the stack  int object2    Another integer is allocated on the stack  object1   object2    The value of object2 is copied to object1   That said  using pointers is NOT necessarily either the correct or the wrong way to handle things  however other answers have covered that satisfactorily  The general idea though is that in C   you have much more control on the lifetime of the objects  and on where they will live  Take home point -- the Object   object   new Object   construct is actually what is closest to typical Java  or C  for that matter  semantics

User · Answer

In C    objects allocated on the stack  using Object object  statement within a block  will only live within the scope they are declared in  When the block of code finishes execution  the object declared are destroyed   Whereas if you allocate memory on heap  using Object  obj   new Object    they continue to live in heap until you call delete obj   I would create an object on heap when I like to use the object not only in the block of code which declared allocated it

User · Answer

But I can t figure out why should we use it like this    I will compare how it works inside the function body if you use   Object myObject    Inside the function  your myObject will get destroyed once this function returns  So this is useful if you don t need your object outside your function  This object will be put on current thread stack   If you write inside function body    Object  myObject   new Object    then Object class instance pointed by myObject will not get destroyed once the function ends  and allocation is on the heap   Now if you are Java programmer  then the second example is closer to how object allocation works under java  This line  Object  myObject   new Object  is equivalent to java  Object myObject   new Object     The difference is that under java myObject will get garbage collected  while under c   it will not get freed  you must somewhere explicitly call  delete myObject   otherwise you will introduce memory leaks   Since c  11 you can use safe ways of dynamic allocations  new Object  by storing values in shared ptr unique ptr   std  shared ptr lt std  string gt  safe str   make shared lt std  string gt   make shared        since c  14 std  unique ptr lt std  string gt  safe str   make unique lt std  string gt   make shared       also  objects are very often stored in containers  like map-s or vector-s  they will automatically manage a lifetime of your objects

User · Answer

Object  myObject   new Object    Doing this will create a reference to an Object  on the heap  which has to be deleted explicitly to avoid memory leak   Object myObject    Doing this will create an object myObject  of the automatic type  on the stack  that will be automatically deleted when the object myObject  goes out of scope

User · Answer

It s very unfortunate that you see dynamic allocation so often  That just shows how many bad C   programmers there are   In a sense  you have two questions bundled up into one  The first is when should we use dynamic allocation  using new   The second is when should we use pointers   The important take-home message is that you should always use the appropriate tool for the job  In almost all situations  there is something more appropriate and safer than performing manual dynamic allocation and or using raw pointers   Dynamic allocation  In your question  you ve demonstrated two ways of creating an object  The main difference is the storage duration of the object  When doing Object myObject  within a block  the object is created with automatic storage duration  which means it will be destroyed automatically when it goes out of scope  When you do new Object    the object has dynamic storage duration  which means it stays alive until you explicitly delete it  You should only use dynamic storage duration when you need it   That is  you should always prefer creating objects with automatic storage duration when you can   The main two situations in which you might require dynamic allocation    You need the object to outlive the current scope - that specific object at that specific memory location  not a copy of it  If you re okay with copying moving the object  most of the time you should be   you should prefer an automatic object  You need to allocate a lot of memory  which may easily fill up the stack  It would be nice if we didn t have to concern ourselves with this  most of the time you shouldn t have to   as it s really outside the purview of C    but unfortunately  we have to deal with the reality of the systems we re developing for    When you do absolutely require dynamic allocation  you should encapsulate it in a smart pointer or some other type that performs RAII  like the standard containers   Smart pointers provide ownership semantics of dynamically allocated objects  Take a look at std  unique ptr and std  shared ptr  for example  If you use them appropriately  you can almost entirely avoid performing your own memory management  see the Rule of Zero    Pointers  However  there are other more general uses for raw pointers beyond dynamic allocation  but most have alternatives that you should prefer  As before  always prefer the alternatives unless you really need pointers    You need reference semantics  Sometimes you want to pass an object using a pointer  regardless of how it was allocated  because you want the function to which you re passing it to have access that that specific object  not a copy of it   However  in most situations  you should prefer reference types to pointers  because this is specifically what they re designed for  Note this is not necessarily about extending the lifetime of the object beyond the current scope  as in situation 1 above  As before  if you re okay with passing a copy of the object  you don t need reference semantics  You need polymorphism  You can only call functions polymorphically  that is  according to the dynamic type of an object  through a pointer or reference to the object  If that s the behavior you need  then you need to use pointers or references  Again  references should be preferred  You want to represent that an object is optional by allowing a nullptr to be passed when the object is being omitted  If it s an argument  you should prefer to use default arguments or function overloads  Otherwise  you should preferably use a type that encapsulates this behavior  such as std  optional  introduced in C  17 - with earlier C   standards  use boost  optional   You want to decouple compilation units to improve compilation time  The useful property of a pointer is that you only require a forward declaration of the pointed-to type  to actually use the object  you ll need a definition   This allows you to decouple parts of your compilation process  which may significantly improve compilation time  See the Pimpl idiom  You need to interface with a C library or a C-style library  At this point  you re forced to use raw pointers  The best thing you can do is make sure you only let your raw pointers loose at the last possible moment  You can get a raw pointer from a smart pointer  for example  by using its get member function  If a library performs some allocation for you which it expects you to deallocate via a handle  you can often wrap the handle up in a smart pointer with a custom deleter that will deallocate the object appropriately

User · Answer

There are many excellent answers already  but let me give you one example   I have an simple Item class    class Item           public         std  string name        int weight        int price           I make a vector to hold a bunch of them   std  vector lt Item gt  inventory   I create one million Item objects  and push them back onto the vector  I sort the vector by name  and then do a simple iterative binary search for a particular item name  I test the program  and it takes over 8 minutes to finish executing  Then I change my inventory vector like so   std  vector lt Item   gt  inventory      and create my million Item objects via new  The ONLY changes I make to my code are to use the pointers to Items  excepting a loop I add for memory cleanup at the end  That program runs in under 40 seconds  or better than a 10x speed increase  EDIT  The code is at http   pastebin com DK24SPeW With compiler optimizations it shows only a 3 4x increase on the machine I just tested it on  which is still considerable

User · Answer

With pointers      can directly talk to the memory   can prevent lot of memory leaks of a program by manipulating pointers

[c++] Why should I use a pointer rather than the object itself?

Examples related to c++

Examples related to c++11

Examples related to pointers

Examples related to c++-faq