What is a smart pointer and when should I use one?

Questions : What is a smart pointer and when should I use one?

What is a smart pointer and when should I use one?

Total Answers: 14 Answers 14


Popular Answers:

  1. UPDATE

    This answer is rather old, and so describes what was ‘good’ at the time, which was smart pointers provided by the Boost library. Since C++11, the standard library has provided sufficient smart pointers types, and so you should favour the use of std::unique_ptr, std::shared_ptr and std::weak_ptr.

    There was also std::auto_ptr. It was very much like a scoped pointer, except that it also had the “special” dangerous ability to be copied — which also unexpectedly transfers ownership.
    It was deprecated in C++11 and removed in C++17, so you shouldn’t use it.

    std::auto_ptr<MyObject> p1 (new MyObject()); std::auto_ptr<MyObject> p2 = p1; // Copy and transfer ownership.  // p1 gets set to empty! p2->DoSomething(); // Works. p1->DoSomething(); // Oh oh. Hopefully raises some NULL pointer exception. 

    OLD ANSWER

    A smart pointer is a class that wraps a ‘raw’ (or ‘bare’) C++ pointer, to manage the lifetime of the object being pointed to. There is no single smart pointer type, but all of them try to abstract a raw pointer in a practical way.

    Smart pointers should be preferred over raw pointers. If you feel you need to use pointers (first consider if you really do), you would normally want to use a smart pointer as this can alleviate many of the problems with raw pointers, mainly forgetting to delete the object and leaking memory.

    With raw pointers, the programmer has to explicitly destroy the object when it is no longer useful.

    // Need to create the object to achieve some goal MyObject* ptr = new MyObject(); ptr->DoSomething(); // Use the object in some way delete ptr; // Destroy the object. Done with it. // Wait, what if DoSomething() raises an exception...? 

    A smart pointer by comparison defines a policy as to when the object is destroyed. You still have to create the object, but you no longer have to worry about destroying it.

    SomeSmartPtr<MyObject> ptr(new MyObject()); ptr->DoSomething(); // Use the object in some way. // Destruction of the object happens, depending  // on the policy the smart pointer class uses. // Destruction would happen even if DoSomething()  // raises an exception 

    The simplest policy in use involves the scope of the smart pointer wrapper object, such as implemented by boost::scoped_ptr or std::unique_ptr.

    void f() { { std::unique_ptr<MyObject> ptr(new MyObject()); ptr->DoSomethingUseful(); } // ptr goes out of scope --  // the MyObject is automatically destroyed. // ptr->Oops(); // Compile error: "ptr" not defined // since it is no longer in scope. } 

    Note that std::unique_ptr instances cannot be copied. This prevents the pointer from being deleted multiple times (incorrectly). You can, however, pass references to it around to other functions you call.

    std::unique_ptrs are useful when you want to tie the lifetime of the object to a particular block of code, or if you embedded it as member data inside another object, the lifetime of that other object. The object exists until the containing block of code is exited, or until the containing object is itself destroyed.

    A more complex smart pointer policy involves reference counting the pointer. This does allow the pointer to be copied. When the last “reference” to the object is destroyed, the object is deleted. This policy is implemented by boost::shared_ptr and std::shared_ptr.

    void f() { typedef std::shared_ptr<MyObject> MyObjectPtr; // nice short alias MyObjectPtr p1; // Empty { MyObjectPtr p2(new MyObject()); // There is now one "reference" to the created object p1 = p2; // Copy the pointer. // There are now two references to the object. } // p2 is destroyed, leaving one reference to the object. } // p1 is destroyed, leaving a reference count of zero.  // The object is deleted. 

    Reference counted pointers are very useful when the lifetime of your object is much more complicated, and is not tied directly to a particular section of code or to another object.

    There is one drawback to reference counted pointers — the possibility of creating a dangling reference:

    // Create the smart pointer on the heap MyObjectPtr* pp = new MyObjectPtr(new MyObject()) // Hmm, we forgot to destroy the smart pointer, // because of that, the object is never destroyed! 

    Another possibility is creating circular references:

    struct Owner { std::shared_ptr<Owner> other; }; std::shared_ptr<Owner> p1 (new Owner()); std::shared_ptr<Owner> p2 (new Owner()); p1->other = p2; // p1 references p2 p2->other = p1; // p2 references p1 // Oops, the reference count of of p1 and p2 never goes to zero! // The objects are never destroyed! 

    To work around this problem, both Boost and C++11 have defined a weak_ptr to define a weak (uncounted) reference to a shared_ptr.

  2. UPDATE:

    This answer is outdated concerning C++ types which were used in the past.
    std::auto_ptr is deprecated and removed in new standards.
    Instead of boost::shared_ptr the std::shared_ptr should be used which is part of the standard.

    The links to the concepts behind the rationale of smart pointers still mostly relevant.

    Modern C++ has the following smart pointer types and doesn’t require boost smart pointers:

    There is also 2-nd edition of the book mentioned in the answer: C++ Templates: The Complete Guide 2nd Edition by David Vandevoorde Nicolai, M. Josuttis, Douglas Gregor


    OLD ANSWER:

    A smart pointer is a pointer-like type with some additional functionality, e.g. automatic memory deallocation, reference counting etc.

    A small intro is available on the page Smart Pointers – What, Why, Which?.

    One of the simple smart-pointer types is std::auto_ptr (chapter 20.4.5 of C++ standard), which allows one to deallocate memory automatically when it out of scope and which is more robust than simple pointer usage when exceptions are thrown, although less flexible.

    Another convenient type is boost::shared_ptr which implements reference counting and automatically deallocates memory when no references to the object remains. This helps avoiding memory leaks and is easy to use to implement RAII.

    The subject is covered in depth in book “C++ Templates: The Complete Guide” by David Vandevoorde, Nicolai M. Josuttis, chapter Chapter 20. Smart Pointers. Some topics covered:

  3. A smart pointer is like a regular (typed) pointer, like “char*”, except when the pointer itself goes out of scope then what it points to is deleted as well. You can use it like you would a regular pointer, by using “->”, but not if you need an actual pointer to the data. For that, you can use “&*ptr”.

    It is useful for:

    • Objects that must be allocated with new, but that you’d like to have the same lifetime as something on that stack. If the object is assigned to a smart pointer, then they will be deleted when the program exits that function/block.

    • Data members of classes, so that when the object is deleted all the owned data is deleted as well, without any special code in the destructor (you will need to be sure the destructor is virtual, which is almost always a good thing to do).

    You may not want to use a smart pointer when:

    • … the pointer shouldn’t actually own the data… i.e., when you are just using the data, but you want it to survive the function where you are referencing it.
    • … the smart pointer isn’t itself going to be destroyed at some point. You don’t want it to sit in memory that never gets destroyed (such as in an object that is dynamically allocated but won’t be explicitly deleted).
    • … two smart pointers might point to the same data. (There are, however, even smarter pointers that will handle that… that is called reference counting.)

    See also:

  4. A smart pointer is an object that acts like a pointer, but additionally provides control on construction, destruction, copying, moving and dereferencing.

    One can implement one’s own smart pointer, but many libraries also provide smart pointer implementations each with different advantages and drawbacks.

    For example, Boost provides the following smart pointer implementations:

    • shared_ptr<T> is a pointer to T using a reference count to determine when the object is no longer needed.
    • scoped_ptr<T> is a pointer automatically deleted when it goes out of scope. No assignment is possible.
    • intrusive_ptr<T> is another reference counting pointer. It provides better performance than shared_ptr, but requires the type T to provide its own reference counting mechanism.
    • weak_ptr<T> is a weak pointer, working in conjunction with shared_ptr to avoid circular references.
    • shared_array<T> is like shared_ptr, but for arrays of T.
    • scoped_array<T> is like scoped_ptr, but for arrays of T.

    These are just one linear descriptions of each and can be used as per need, for further detail and examples one can look at the documentation of Boost.

    Additionally, the C++ standard library provides three smart pointers; std::unique_ptr for unique ownership, std::shared_ptr for shared ownership and std::weak_ptr. std::auto_ptr existed in C++03 but is now deprecated.

  5. Most kinds of smart pointers handle disposing of the pointer-to object for you. It’s very handy because you don’t have to think about disposing of objects manually anymore.

    The most commonly-used smart pointers are std::tr1::shared_ptr (or boost::shared_ptr), and, less commonly, std::auto_ptr. I recommend regular use of shared_ptr.

    shared_ptr is very versatile and deals with a large variety of disposal scenarios, including cases where objects need to be “passed across DLL boundaries” (the common nightmare case if different libcs are used between your code and the DLLs).

  6. Here is the Link for similar answers : http://sickprogrammersarea.blogspot.in/2014/03/technical-interview-questions-on-c_6.html

    A smart pointer is an object that acts, looks and feels like a normal pointer but offers more functionality. In C++, smart pointers are implemented as template classes that encapsulate a pointer and override standard pointer operators. They have a number of advantages over regular pointers. They are guaranteed to be initialized as either null pointers or pointers to a heap object. Indirection through a null pointer is checked. No delete is ever necessary. Objects are automatically freed when the last pointer to them has gone away. One significant problem with these smart pointers is that unlike regular pointers, they don’t respect inheritance. Smart pointers are unattractive for polymorphic code. Given below is an example for the implementation of smart pointers.

    Example:

    template <class X> class smart_pointer { public: smart_pointer(); // makes a null pointer smart_pointer(const X& x) // makes pointer to copy of x X& operator *( ); const X& operator*( ) const; X* operator->() const; smart_pointer(const smart_pointer <X> &); const smart_pointer <X> & operator =(const smart_pointer<X>&); ~smart_pointer(); private: //... }; 

    This class implement a smart pointer to an object of type X. The object itself is located on the heap. Here is how to use it:

    smart_pointer <employee> p= employee("Harris",1333); 

    Like other overloaded operators, p will behave like a regular pointer,

    cout<<*p; p->raise_salary(0.5); 
  7. Let T be a class in this tutorial Pointers in C++ can be divided into 3 types :

    1) Raw pointers :

    T a; T * _ptr = &a; 

    They hold a memory address to a location in memory. Use with caution , as programs become complex hard to keep track.

    Pointers with const data or address { Read backwards }

    T a ; const T * ptr1 = &a ; T const * ptr1 = &a ; 

    Pointer to a data type T which is a const. Meaning you cannot change the data type using the pointer. ie *ptr1 = 19 ; will not work. But you can move the pointer. ie ptr1++ , ptr1-- ; etc will work. Read backwards : pointer to type T which is const

     T * const ptr2 ; 

    A const pointer to a data type T . Meaning you cannot move the pointer but you can change the value pointed to by the pointer. ie *ptr2 = 19 will work but ptr2++ ; ptr2-- etc will not work. Read backwards : const pointer to a type T

    const T * const ptr3 ; 

    A const pointer to a const data type T . Meaning you cannot either move the pointer nor can you change the data type pointer to be the pointer. ie . ptr3-- ; ptr3++ ; *ptr3 = 19; will not work

    3) Smart Pointers : { #include <memory> }

    Shared Pointer:

     T a ; //shared_ptr<T> shptr(new T) ; not recommended but works  shared_ptr<T> shptr = make_shared<T>(); // faster + exception safe std::cout << shptr.use_count() ; // 1 // gives the number of "  things " pointing to it. T * temp = shptr.get(); // gives a pointer to object // shared_pointer used like a regular pointer to call member functions shptr->memFn(); (*shptr).memFn(); // shptr.reset() ; // frees the object pointed to be the ptr shptr = nullptr ; // frees the object shptr = make_shared<T>() ; // frees the original object and points to new object 

    Implemented using reference counting to keep track of how many ” things ” point to the object pointed to by the pointer. When this count goes to 0 , the object is automatically deleted , ie objected is deleted when all the share_ptr pointing to the object goes out of scope. This gets rid of the headache of having to delete objects which you have allocated using new.

    Weak Pointer : Helps deal with cyclic reference which arises when using Shared Pointer If you have two objects pointed to by two shared pointers and there is an internal shared pointer pointing to each others shared pointer then there will be a cyclic reference and the object will not be deleted when shared pointers go out of scope. To solve this , change the internal member from a shared_ptr to weak_ptr. Note : To access the element pointed to by a weak pointer use lock() , this returns a weak_ptr.

    T a ; shared_ptr<T> shr = make_shared<T>() ; weak_ptr<T> wk = shr ; // initialize a weak_ptr from a shared_ptr  wk.lock()->memFn() ; // use lock to get a shared_ptr  // ^^^ Can lead to exception if the shared ptr has gone out of scope if(!wk.expired()) wk.lock()->memFn() ; // Check if shared ptr has gone out of scope before access 

    See : When is std::weak_ptr useful?

    Unique Pointer : Light weight smart pointer with exclusive ownership. Use when pointer points to unique objects without sharing the objects between the pointers.

    unique_ptr<T> uptr(new T); uptr->memFn(); //T * ptr = uptr.release(); // uptr becomes null and object is pointed to by ptr uptr.reset() ; // deletes the object pointed to by uptr  

    To change the object pointed to by the unique ptr , use move semantics

    unique_ptr<T> uptr1(new T); unique_ptr<T> uptr2(new T); uptr2 = std::move(uptr1); // object pointed by uptr2 is deleted and  // object pointed by uptr1 is pointed to by uptr2 // uptr1 becomes null  

    References : They can essentially be though of as const pointers, ie a pointer which is const and cannot be moved with better syntax.

    See : What are the differences between a pointer variable and a reference variable in C++?

    r-value reference : reference to a temporary object l-value reference : reference to an object whose address can be obtained const reference : reference to a data type which is const and cannot be modified 

    Reference : https://www.youtube.com/channel/UCEOGtxYTB6vo6MQ-WQ9W_nQ Thanks to Andre for pointing out this question.

  8. http://en.wikipedia.org/wiki/Smart_pointer

    In computer science, a smart pointer is an abstract data type that simulates a pointer while providing additional features, such as automatic garbage collection or bounds checking. These additional features are intended to reduce bugs caused by the misuse of pointers while retaining efficiency. Smart pointers typically keep track of the objects that point to them for the purpose of memory management. The misuse of pointers is a major source of bugs: the constant allocation, deallocation and referencing that must be performed by a program written using pointers makes it very likely that some memory leaks will occur. Smart pointers try to prevent memory leaks by making the resource deallocation automatic: when the pointer to an object (or the last in a series of pointers) is destroyed, for example because it goes out of scope, the pointed object is destroyed too.

  9. A smart pointer is a class, a wrapper of a normal pointer. Unlike normal pointers, smart point’s life circle is based on a reference count (how many time the smart pointer object is assigned). So whenever a smart pointer is assigned to another one, the internal reference count plus plus. And whenever the object goes out of scope, the reference count minus minus.

    Automatic pointer, though looks similar, is totally different from smart pointer. It is a convenient class that deallocates the resource whenever an automatic pointer object goes out of variable scope. To some extent, it makes a pointer (to dynamically allocated memory) works similar to a stack variable (statically allocated in compiling time).

  10. What is a smart pointer.

    Long version, In principle:

    https://web.stanford.edu/class/archive/cs/cs106l/cs106l.1192/lectures/lecture15/15_RAII.pdf

    A modern C++ idiom:

    RAII: Resource Acquisition Is Initialization. ● When you initialize an object, it should already have acquired any resources it needs (in the constructor). ● When an object goes out of scope, it should release every resource it is using (using the destructor). 

    key point:

    ● There should never be a half-ready or half-dead object. ● When an object is created, it should be in a ready state. ● When an object goes out of scope, it should release its resources. ● The user shouldn’t have to do anything more. 

    Raw Pointers violate RAII: It need user to delete manually when the pointers go out of scope.

    RAII solution is:

    Have a smart pointer class: ● Allocates the memory when initialized ● Frees the memory when destructor is called ● Allows access to underlying pointer 

    For smart pointer need copy and share, use shared_ptr:

    ● use another memory to store Reference counting and shared. ● increment when copy, decrement when destructor. ● delete memory when Reference counting is 0. also delete memory that store Reference counting. 

    for smart pointer not own the raw pointer, use weak_ptr:

    not change Reference counting. 

    shared_ptr usage:

    correct way: std::shared_ptr<T> t1 = std::make_shared<T>(TArgs); std::shared_ptr<T> t2 = std::shared_ptr<T>(new T(Targs)); wrong way: T* pt = new T(TArgs); // never exposure the raw pointer shared_ptr<T> t1 = shared_ptr<T>(pt); shared_ptr<T> t2 = shared_ptr<T>(pt); 

    Always avoid using raw pointer.

    For scenario that have to use raw pointer:

    https://stackoverflow.com/a/19432062/2482283

    For raw pointer that not nullptr, use reference instead.

    not use T* use T& 

    For optional reference which maybe nullptr, use raw pointer, and which means:

    T* pt; is optional reference and maybe nullptr. Not own the raw pointer, Raw pointer is managed by some one else. I only know that the caller is sure it is not released now. 
  11. Smart Pointers are those where you don’t have to worry about Memory De-Allocation, Resource Sharing and Transfer.

    You can very well use these pointer in the similar way as any allocation works in Java. In java Garbage Collector does the trick, while in Smart Pointers, the trick is done by Destructors.

  12. The existing answers are good but don’t cover what to do when a smart pointer is not the (complete) answer to the problem you are trying to solve.

    Among other things (explained well in other answers) using a smart pointer is a possible solution to How do we use a abstract class as a function return type? which has been marked as a duplicate of this question. However, the first question to ask if tempted to specify an abstract (or in fact, any) base class as a return type in C++ is “what do you really mean?”. There is a good discussion (with further references) of idiomatic object oriented programming in C++ (and how this is different to other languages) in the documentation of the boost pointer container library. In summary, in C++ you have to think about ownership. Which smart pointers help you with, but are not the only solution, or always a complete solution (they don’t give you polymorphic copy) and are not always a solution you want to expose in your interface (and a function return sounds an awful lot like an interface). It might be sufficient to return a reference, for example. But in all of these cases (smart pointer, pointer container or simply returning a reference) you have changed the return from a value to some form of reference. If you really needed copy you may need to add more boilerplate “idiom” or move beyond idiomatic (or otherwise) OOP in C++ to more generic polymorphism using libraries like Adobe Poly or Boost.TypeErasure.

  13. A stub is a test double that returns values to the SUT.

    A mock is a test double that a test uses to verify that the SUT correctly invokes a dependency.

    Also, a mock is often a stub

  14. Stub

    A stub is an object that holds predefined data and uses it to answer calls during tests. It is used when you can’t or don’t want to involve objects that would answer with real data or have undesirable side effects.

    An example can be an object that needs to grab some data from the database to respond to a method call. Instead of the real object, we introduced a stub and defined what data should be returned.

    enter image description here

    example of Stub:

    public class GradesService { private final Gradebook gradebook; public GradesService(Gradebook gradebook) { this.gradebook = gradebook; } Double averageGrades(Student student) { return average(gradebook.gradesFor(student)); } } 

    Instead of calling database from Gradebook store to get real students grades, you preconfigure stub with grades that will be returned. You define just enough data to test average calculation algorithm.

    public class GradesServiceTest { private Student student; private Gradebook gradebook; @Before public void setUp() throws Exception { gradebook = mock(Gradebook.class); student = new Student(); } @Test public void calculates_grades_average_for_student() { //stubbing gradebook when(gradebook.gradesFor(student)).thenReturn(grades(8, 6, 10)); double averageGrades = new GradesService(gradebook).averageGrades(student); assertThat(averageGrades).isEqualTo(8.0); } } 

    Mock

    Mocks are objects that register calls they receive. In test assertion you can verify on Mocks that all expected actions were performed. You use mocks when you don’t want to invoke production code or when there is no easy way to verify, that intended code was executed. There is no return value and no easy way to check system state change. An example can be a functionality that calls e-mail sending service.

    You don’t want to send e-mails each time you run a test. Moreover, it is not easy to verify in tests that a right email was send. Only thing you can do is to verify the outputs of the functionality that is exercised in our test. In other worlds, verify that the e-mail sending service was called.

    enter image description here

    Example of Mock:

    public class SecurityCentral { private final Window window; private final Door door; public SecurityCentral(Window window, Door door) { this.window = window; this.door = door; } void securityOn() { window.close(); door.close(); } } 

    You don’t want to close real doors to test that security method is working, right? Instead, you place door and window mocks objects in the test code.

    public class SecurityCentralTest { Window windowMock = mock(Window.class); Door doorMock = mock(Door.class); @Test public void enabling_security_locks_windows_and_doors() { SecurityCentral securityCentral = new SecurityCentral(windowMock, doorMock); securityCentral.securityOn(); verify(doorMock).close(); verify(windowMock).close(); } } 

    Thanks a lot to Michał Lipski for his good article. For further reading:

    Test Double – Martin Fowler https://martinfowler.com/bliki/TestDouble.html
    Test Double – xUnit Patterns http://xunitpatterns.com/Test%20Double.html
    Mocks Aren’t Stubs – Martin Fowler https://martinfowler.com/articles/mocksArentStubs.html
    Command Query Separation – Martin Fowler https://martinfowler.com/bliki/CommandQuerySeparation.html

  15. A stub is an empty function which is used to avoid unhandled exceptions during tests:

    function foo(){} 

    A mock is an artificial function which is used to avoid OS, environment or hardware dependencies during tests:

    function foo(bar){ window = this; return window.toString(bar); } 

    In terms of assertions and state:

    • Mocks are asserted before an event or state change
    • Stubs are not asserted, they provide state before an event to avoid executing code from unrelated units
    • Spies are setup like stubs, then asserted after an event or state change
    • Fakes are not asserted, they run after an event with hardcoded dependencies to avoid state

    References

  16. Say you have a class named EmployeeService that you want to test and that has one dependency on an interface named EmployeeDao:

    public class EmployeeService{ private EmployeeDao dao; public EmployeeService(Dao dao){this.dao = dao;} public String getEmployeeName(int id){ Employee emp = bar.goToDatabaseAndBringTheEmployeeWithId(id); return emp != null?emp.getFullName:null; } //Further state and behavior } public interface EmployeeDao{ Employee goToDatabaseAndBringTheEmployeeWithId(int id); } 

    Inside your test class:

    public class EmployeeServiceTest{ EmployeeService service; EmployeeDao mockDao = Mockito.mock(EmployeeDao.class);//Line 3 @Before public void setUp(){ service = new EmployeeService(mockDao); } //Tests //.... } 

    In the above test class in line 3, we say to the mocking framework (in this case Mockito) “Hey, Mockito, craft me an object that has the EmployeeDao functionality.” The framework is going to create an object that has the method goToDatabaseAndBringTheEmployeeWithId but actually with no body. It’s your job to instruct that mock what to do. This is a mock.

    But you could also create a class that implements the EmployeeDao interface and use it in the test class instead:

    public EmployeeDaoStub implements EmployeeDao{ public Employee goToDatabaseAndBringTheEmployeeWithId(int id){ //No trip to DB, just returning a dummy Employee object return new Employee("John","Woo","123 Lincoln str"); } } 

    Inside your test class this time using stub instead of a mock:

    public class EmployeeServiceTest{ EmployeeService service; EmployeeDao daoStub = new EmployeeDaoStub();//Line 3 @Before public void setUp(){ service = new EmployeeService(daoStub); } //Tests //.... } 

    So to wrap it all, stubs are the classes that you create(or somebody else does) specifically to imitate some dependency just for the sake of having the desired state. Yes, as all the other people state, it’s mostly about a state Whereas mocks are typically created by a mocking framework and you have no idea what its guts look like. But with stubs you know what class you’re going to get: It’s the one you created.

    Oh, btw, if your dependency is a class rather than an interface, you can just extend that class to create your stub.

  17. A Stub is an object that implements an interface of a component, but instead of returning what the component would return when called, the stub can be configured to return a value that suits the test. Using stubs a unit test can test if a unit can handle various return values from its collaborator. Using a stub instead of a real collaborator in a unit test could be expressed like this:

    unit test –> stub

    unit test –> unit –> stub

    unit test asserts on results and state of unit

    First the unit test creates the stub and configures its return values. Then the unit test creates the unit and sets the stub on it. Now the unit test calls the unit which in turn calls the stub. Finally the unit test makes assertions about the results of the method calls on the unit.

    A Mock is like a stub, only it also has methods that make it possible determine what methods where called on the Mock. Using a mock it is thus possible to both test if the unit can handle various return values correctly, and also if the unit uses the collaborator correctly. For instance, you cannot see by the value returned from a dao object whether the data was read from the database using a Statement or a PreparedStatement. Nor can you see if the connection.close() method was called before returning the value. This is possible with mocks. In other words, mocks makes it possible to test a units complete interaction with a collaborator. Not just the collaborator methods that return values used by the unit. Using a mock in a unit test could be expressed like this:

    unit test –> mock

    unit test –> unit –> mock

    unit test asserts on result and state of unit

    unit test asserts on the methods called on mock

    More Detail >> Here

  18. A stub is a fake object built for test purposes. A mock is a stub that records whether expected calls effectively occurred.

  19. Mock – A mock intercepts a call to a method or function (or a group of methods and functions like in the case of a mocked class). It is not an alternative to that method or function. In that interception, the mock can do whatever it wants, such as record the input and output, decide to short circuit the call, change the returned value, etc.

    Stub – A stub is a valid full working implementation of a method or function (or group of methods and functions like in the case of a stubbed class) that has an identical interface/signature to the method, function or group of methods and functions it is stubbing for. The stubbed implementation will generally only do things that are acceptable within the context of a unit test, that means it won’t do IO for example, while mimicking the behavior of the thing it is stubbing.

  20. A test subject performs actions in response to certain prompts (function calls) or other stimuli. Here are concrete examples of test situations.

    Scenario — EMT student exam

    A student has studied to be an Emergency Medical Technician. Go watch Ian Gallagher in Shameless Season 6, Episode 10 if you are unfamiliar with this test situation.

    It is too expensive to find patients with various illnesses for test purposes. Instead we use actors. We ask the test subject (Ian) “you arrive on the scene and the patient is immobilized and unconscious what do you do first?” Ian responds “I check if the scene is safe”. And the test instructor says “the scene is safe”.

    The instructor (and actor) are able to inject arbitrary answers to the test subject’s queries.

    Here, the instructor (and actor) are a mock. Medical training uses this terminology (e.g. mock code simulation) the same as computer scientists.

    Scenario — register for a website

    You are testing Yahoo, a new email service you heard about. In order to sign up, you must provide your birthday and answers to other intrusive questions.

    The website requires that you are 21 years or older. So you enter in the value January 1, 1970. It meets the requirements and it saves you from the laborious process of implementing a remember-my-birthday-and-type-it-in workflow.

    This date is a stub. This word usage is specific to computer science.

  21. There a lots of greats answers, and I liked this one, so I turned it into a table.

    Dummy Stub Mock Fake
    API O O O O
    States X O O O
    Values X X O O
    Behavior X X X O
  22. following is my understanding…

    • if you create test objects locally and feed your local service with that, you are using mock object. this will give a test for the method you implemented in your local service. it is used to verify behaviors

    • when you get the test data from the real service provider, though from a test version of interface and get a test version of the object, you are working with stubs the stub can have logic to accept certain input and give corresponding output to help you perform state verification…

  23. Stubs are used on methods with an expected return value which you setup in your test. Mocks are used on void methods which are verified in the Assert that they are called.

Tasg: c++, pointers

Answer Link
jidam
  • Unable to run NoraUI mvn verify goal
  • Unable to run my app on emulator in VS Code
  • Unable to run multiple instances of libVLC(MobileVLCKit) in IOS via flutter framework
  • Unable to run make on griddb source on ubuntu 20.04 (building from source)
  • Unable to run latexindent macOS Monterey 12.0.1
  • Unable to run kotlinc-native command
  • Unable to run JUnit Test… Java.lang.ExceptionInInitializerError (Android Studio)
  • Unable to run java with -Xmx > 966m
  • Unable to run ionic cap run android from wsl2 inorder to start android emulator
  • Unable to run Intel HAXM installer: Cannot start process, the working directory does not exist
  • fs
  • Unable to run Google Analytics sample code
  • unable to run flutter run after upgarding to flutter 2.8.0 from 2.5.3
  • Unable to run Django with PostgreSQL in Docker
  • Unable to Run Container Using testcontainers
  • Unable to run ClojureScript Hello World program, Error building classpath. Error reading edn.