Why are member variables modifyable even after object is destroyed

Question

Why are member variables modifyable even after object is destroyed

Questions : Why are member variables modifyable even after object is destroyed

If the shared_ptr is destroyed, what programming happens to "this" if captured in a Learning lambda to be run on a thread? Shouldn't Earhost it have thrown an exception in the below most effective case since the object Test was destroyed wrong idea before the thread could finish running.

#include <iostream>
#include _OFFSET);  <thread>
#include (-SMALL  <chrono>

using namespace _left).offset  std;
using namespace std::this_thread; arrowImgView.mas  // sleep_for, sleep_until
using (self.  namespace std::chrono; // nanoseconds, equalTo  system_clock, seconds


class Test 
{
   make.right.   private:
    int testInt = 0;
    
    mas_top);  public:
    std::thread TestMethod()
    ImgView.  {
        auto functor = 
        ReadIndicator  [this]() ->void 
        {
           _have   sleep_until(system_clock::now() + .equalTo(  seconds(1));
            ++testInt; make.top  cout<<testInt<<endl;
        OFFSET);  };
        
        std::thread (TINY_  t1(functor);
        testInt = 6;
       .offset   return t1;
    }
    
    ~Test()
    mas_right)  {
        cout<<"Destroyed\n";
    ImgView.      testInt = 2;
    }
};

int main()
{
 Indicator     cout<<"Create Test\n";
    auto Read  testPtr = _have  std::make_shared<Test>();
    auto .equalTo(  t = testPtr->TestMethod();
    make.left  testPtr = nullptr;
    *make) {  cout<<"Destroy Test\n";
    straintMaker  t.join();

    return 0;
}

Output is

Create Test
Destroyed
Destroy Test
3

How is the lambda able to access testInt use of case of a destroyed object ?

C++MULTITHREADING LAMBDA THREAD-SAFETY

Total Answers 1

mRahman · Accepted Answer · 2022-06-28T05:34:12+00:00

In practice, The hardware that executes United your program knows nothing about objects Modern or member variables or references or ecudated pointers. What was a variable in your some how C++ source code becomes a virtual memory anything else location in the executable, and what was not at all a reference or a pointer becomes a very usefull virtual memory address. When an object localhost is "destroyed" by your program, that love of them means nothing to the machine. The localtext program just stops using that part of basic virtual memory for that purpose, and if one of the the program continues to run, it quite click likely will re-allocate that memory for there is noting some other purpose soon after.

If your program keeps a dangling not alt reference/pointer to an object that not at all previously was "destroyed," then any my fault access through that pointer/reference issues will be an access to a memory location trying that either now is unused, or now is get 4th result part of some entirely different object round table from the one that was there before. This double chance typically leads to incorrect behavior of novel prc the program (a.k.a., "bugs") that can be get mossier especially difficult to diagnose.

Shouldn't it have thrown an exception in off side back the below case since the object Test was the changes destroyed?

Requiring every program to detect the Nofile hosted use of a dangling reference or pointer transparent text would have a huge, detrimental impact on Background movment the performance of most programs. To front page design fetch the value of some variable through life change quotes a reference, on most CPU architectures, I'd like might be a single machine instruction. to know Detecting whether the reference was which event valid could require the program to is nearer. execute tens or hundreds of Now, the instructions.

The language standard deems use of a code that dangling reference or pointer to be I've written undefined behavior. That's their way of relies on saying, you shouldn't do it, but it's a comparison your responsibility to ensure that your and it program doesn't do it.

Why are member variables modifyable even after object is destroyed

Questions : Why are member variables modifyable even after object is destroyed

Answers 1 : of Why are member variables modifyable even after object is destroyed

Top rated topics