I have a function that is called from multiple threads:  void func() {    static MyObject someobject;    someobject.complexFunc(); }   At program termination, can I assume that someobject is destroyed after the last thread has been terminated? If no, how can I make sure threads don't access it anymore when say std::exit is called?  Thanks
24968
If a variable is declared as static in a function's scope it is only initialized once and retains its value between function calls. What exactly is its lifetime? When do its constructor and destructor get called?  void foo()  {      static string plonk = "When will I die?"; }
80384
Why do we need to close a FileInputStream (and streams in general) in any case before we leave the program? What would happen otherwise? If the program stops before the input stream is closed explicitly in the program, doesn't the stream also close automatically?
34221
I guess the question says it all, but, what happens if someone closes a c++ console app? As in, clicks the "x" in the top corner. Does it instantly close? Does it throw some sort of exception? Is it undefined behavior?
14089
I'm creating a function where I need to pass an object so that it can be modified by the function. What is the difference between:  public void myFunction(ref MyClass someClass)   and  public void myFunction(out MyClass someClass)   Which should I use and why?
2935
I am fascinated by the way the CLR and GC works (I'm working on expanding my knowledge on this by reading CLR via C#, Jon Skeet's books/posts, and more).  Anyway, what is the difference between saying:  MyClass myclass = new MyClass(); myclass = null;   Or, by making MyClass implement IDisposable and a destructor and calling Dispose()?  Also, if I have a code block with a using statement (eg below), if I step through the code and exit the using block, is the object disposed of then or when a garbage collection occurs? What would happen if I call Dispose() in the using block anyay?  using (MyDisposableObj mydispobj = new MyDisposableObj()) {  }   Stream classes (eg BinaryWriter) have a Finalize method? Why would I want to use that?
98843
In my initial basic tests it is perfectly safe to do so.  However, it has struck me that attempting to manipulate this later in a function that deletes this could be a runtime error.  Is this true, and is it normally safe to delete this? or are there only certain cases wherein it is safe?
31631
I think we all understand the necessity of delete when reassigning a dynamically-allocated pointer in order to prevent memory leaks. However, I'm curious, to what extent does the C++ mandate the usage of delete? For example, take the following program  int main() {      int* arr = new int[5];      return 0; }   While for all intents and purposes no leak occurs here (since your program is ending and the OS will clean up all memory once it returns), but does the standard still require -- or recommend -- the usage of delete[] in this case? If not, would there be any other reason why you would delete[] here?
58355
I have the following code:  MemoryStream foo(){     MemoryStream ms = new MemoryStream();     // write stuff to ms     return ms; }  void bar(){     MemoryStream ms2 = foo();     // do stuff with ms2     return; }   Is there any chance that the MemoryStream that I've allocated will somehow fail to be disposed of later?    I've got a peer review insisting that I manually close this, and I can't find the information to tell if he has a valid point or not.
54935
How would you go about finding out how much memory is being used by an object? I know it is possible to find out how much is used by a block of code, but not by an instantiated object (anytime during its life), which is what I want.
69794
Should objects be disposed when using the client object model?  If so, which ones?  There seems to be plenty of information on this for server side, but nothing from Microsoft specifically about client side.
45838
If I have the following code:  MyClass pClass = new MyClass(); pClass.MyEvent += MyFunction; pClass = null;   Will pClass be garbage collected? Or will it hang around still firing its events whenever they occur? Will I need to do the following in order to allow garbage collection?  MyClass pClass = new MyClass(); pClass.MyEvent += MyFunction; pClass.MyEvent -= MyFunction; pClass = null;
119943
I'm reading the  function in /init/main.c.  The last function called in start_kernel is rest_init, and at the end of rest_init, cpu_idle is called.   Why is it called as the last function of the start_kernel routine, and what does it do?
26363
I've seen the word static used in different places in C code; is this like a static function/class in C# (where the implementation is shared across objects)?
19458
Ignoring programming style and design, is it "safe" to call delete on a variable allocated on the stack?  For example:     int nAmount;    delete &amp;nAmount;   or  class sample { public:     sample();     ~sample() { delete &amp;nAmount;}     int nAmount; }
31989
Something that confuses me, but has never caused any problems... the recommended way to dispatch an event is as follows:  public event EventHandler SomeEvent; ... {     ....     if(SomeEvent!=null)SomeEvent(); }   In a multi-threaded environment, how does this code guarantee that another thread will not alter the invocation list of SomeEvent between the check for null and the invocation of the event?
55847
The Java documentation says:      It is not possible for two invocations of synchronized methods on the   same object to interleave.   What does this mean for a static method?  Since a static method has no associated object, will the synchronized keyword lock on the class, instead of the object?
55025
So I was just working with function pointers and I remembered that you could do this:  void Foo() { }  int main() {     void(&amp; func)() = Foo;      func(); //::Foo(); }   The obvious advantage being that references reference valid objects (unless they're misused), or functions in this case.  The obvious disadvantages being that you can't store an array of references and can't use them for member function pointers (at least as far as I can tell).  My question: does anyone use them (i.e., function references, not function pointers), and if so, in what scenarios have you found them useful/helpful?  The only place I can see them being useful off the bat is binding a reference to a certain function when working with conditional compilation.