{"id":1972,"date":"2025-01-26T20:57:37","date_gmt":"2025-01-26T20:57:37","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/?page_id=1972"},"modified":"2025-01-27T19:00:33","modified_gmt":"2025-01-27T19:00:33","slug":"resource-acquisition","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/topics\/c-details\/exceptions-2\/resource-acquisition\/","title":{"rendered":"Resource Acquisition"},"content":{"rendered":"\n

<\/span>Resource Acquisition<\/span><\/h2>\n\n\n\n

When a program acquires a resource (e.g. opens a file, allocates some memory, sets a lock, etc.), it is often very important for the future operation of the program that the resource is properly released.<\/p>\n\n\n\n

For example, in normal C\/C++, this is typically handled like:<\/p>\n\n\n\n

\n
\n
<\/path><\/path><\/svg><\/span>
void<\/span> <\/span>useFile<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>filename<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  FILE *fp = <\/span>fopen<\/span>(filename, <\/span>"w"<\/span>);<\/span><\/span>\n  \/\/ use fp<\/span><\/span>\n  <\/span>fclose<\/span>(fp);<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
but this is not safe when something goes wrong – for example, if the program fails to open the file, or an error occurs while accessing the file.<\/p>\n<\/div>\n<\/div>\n\n\n\n
A better approach might be:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
void<\/span> <\/span>useFile<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>filename<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  FILE *fp = <\/span>fopen<\/span>(filename, <\/span>"w"<\/span>);<\/span><\/span>\n  <\/span>try<\/span><\/span>\n  {<\/span><\/span>\n    \/\/ use fp<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>catch<\/span>(...)<\/span><\/span>\n  {<\/span><\/span>\n    <\/span>fclose<\/span>(f);<\/span> \/\/ close on exception<\/span><\/span>\n    <\/span>throw<\/span>;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>fclose<\/span>(fp);<\/span>\t\/\/ close normally<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
This is better, but it is verbose, tedious, potentially expensive, and error-prone.<\/p>\n<\/div>\n<\/div>\n\n\n\n
The general form of such a program looks like:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
void<\/span> <\/span>acquire_and_release<\/span>()<\/span><\/span>\n{<\/span><\/span>\n  \/\/ acquire resource 1<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n  \/\/ acquire resource n<\/span><\/span>\n  \/\/ use resources<\/span><\/span>\n  \/\/ release resource n<\/span><\/span>\n  \/\/ ...<\/span><\/span>\n  \/\/ release resource 1<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
Note the typical release sequence is in the reverse order of acquisition.<\/em><\/strong><\/p>\n<\/div>\n<\/div>\n\n\n\n
This resembles the behavior of objects created by constructors and destroyed by destructors.<\/p>\n\n\n\n
So we could design a class to solve the problem:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  FilePtr.cpp<\/span><\/span>\n\/\/  Derived Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/4\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>FilePtr<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>FilePtr<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>name<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>access<\/span>)<\/span><\/span>\n  { <\/span><\/span>\n    fp = <\/span>fopen<\/span>(name, access);<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>FilePtr<\/span>(<\/span>FILE<\/span> <\/span>*<\/span>f<\/span>) : <\/span>fp<\/span>(f) {}<\/span><\/span>\n  <\/span>~FilePtr<\/span>() { <\/span>fclose<\/span>(fp); }<\/span><\/span>\n\t<\/span><\/span>\n  <\/span>operator<\/span> <\/span>FILE<\/span> <\/span>*<\/span>() { <\/span>return<\/span> fp; }<\/span><\/span>\nprivate:<\/span><\/span>\n  FILE *fp;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>useFile<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>filename<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  FilePtr <\/span>file<\/span>(filename, <\/span>"r"<\/span>);<\/span><\/span>\n  \/\/ use file...<\/span><\/span>\n  \/\/ Destructor for file will be called <\/span><\/span>\n  \/\/ whether an exception is thrown or not.<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>useFile<\/span>(<\/span>argv<\/span>[<\/span>1<\/span>]);<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
<\/div>\n<\/div>\n\n\n\n
<\/span>“Resource acquisition is initialization.”<\/em><\/strong> (RAII)<\/span><\/h2>\n\n\n\n
\n
This technique is called “Resource acquisition is initialization<\/em>” <\/strong>or RAII<\/em><\/strong>. <\/p>\n\n\n\n
It is considered to be a critical technique in C++. (See here for more details.<\/a>)<\/p>\n<\/blockquote>\n\n\n\n
An object is not considered (fully) constructed until its constructor has completed.  Then, and only then, will stack unwinding (as a result of throwing an exception) call the destructor for the object.<\/p>\n\n\n\n
Consider a class whose constructor needs to acquire two resources, a file x<\/em><\/strong> and a lock y<\/em><\/strong>:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
class<\/span> <\/span>Resources<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Resources<\/span>(<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>file<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>lock<\/span>)<\/span><\/span>\n    :\t<\/span>m_file<\/span>(x),<\/span>  \/\/ acquire 'file'<\/span><\/span>\n      <\/span>m_lock<\/span>(y)<\/span>\t  \/\/ acquire 'lock'<\/span><\/span>\n  {}<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n  FilePtr m_file;<\/span><\/span>\n  LockPtr m_lock;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
If an exception occurs after file has been constructed, but before lock has been constructed, then the destructor for file will be invoked, but the destructor for lock will not.<\/p>\n\n\n\n
When this simple model is adhered to, the author of the constructor need not write explicit exception handling code.<\/p>\n<\/div>\n<\/div>\n\n\n\n
The most common resource is free store (memory).  For example:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
class<\/span> <\/span>X<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>X<\/span>(<\/span>int<\/span> <\/span>size<\/span>) { m_p = <\/span>new<\/span> <\/span>int<\/span>[size]; <\/span>init<\/span>(); }<\/span><\/span>\n  <\/span>~X<\/span>() { <\/span>delete<\/span> <\/span>[]<\/span> m_p; }<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>void<\/span> <\/span>init<\/span>();<\/span><\/span>\n  <\/span>int<\/span> *m_p;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
\n
But this code leads to memory leaks<\/em> when used with exceptions \u2013 if init()<\/code><\/strong> throws an exception, then the memory acquired will not be freed, because the object wasn’t completely constructed.<\/p>\n<\/div>\n<\/div>\n\n\n\n
A safe version is:<\/p>\n\n\n\n
\n
\n
<\/path><\/path><\/svg><\/span>
\/\/<\/span><\/span>\n\/\/  SafeMemory.cpp<\/span><\/span>\n\/\/  Derived Exceptions<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/4\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><stdio.h><\/span><\/span>\n<\/span>\nclass<\/span> <\/span>IntPtr<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>IntPtr<\/span>(<\/span>size_t<\/span> <\/span>size<\/span>) : <\/span>m_p<\/span>( <\/span>new<\/span> <\/span>int<\/span>[size] ) {}<\/span><\/span>\n  <\/span>~IntPtr<\/span>() { <\/span>delete<\/span> <\/span>[]<\/span> m_p; }<\/span><\/span>\n  <\/span>operator<\/span> <\/span>int*<\/span>() { <\/span>return<\/span> m_p; }<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>int<\/span> *m_p;<\/span><\/span>\n};<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Z<\/span><\/span>\n{<\/span><\/span>\npublic:<\/span><\/span>\n  <\/span>Z<\/span>(<\/span>int<\/span> <\/span>size<\/span>) : <\/span>m_p<\/span>(size) { <\/span>init<\/span>(); }<\/span><\/span>\n  <\/span>~Z<\/span>() { <\/span>delete<\/span> <\/span>[]<\/span> m_p; }<\/span><\/span>\n  \/\/ ...<\/span><\/span>\nprivate:<\/span><\/span>\n  <\/span>void<\/span> <\/span>init<\/span>();<\/span><\/span>\n  IntPtr m_p;<\/span><\/span>\n};<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
<\/div>\n<\/div>\n\n\n\n
\n
“In the C++ standard library, RAII is pervasive: for example, memory (string, vector, map, unordered_map, etc.), files (ifstream, ofstream, etc.), threads (thread), locks (lock_guard, unique_lock, etc.), and general objects (through unique_ptr and shared_ptr). The result is implicit resource management that is invisible in common use and leads to low resource retention durations.<\/em><\/p>\n\n\n\n
~ Bjarne Stroustrup. A Tour of C++ 3rd Edition.<\/p>\n<\/blockquote>\n\n\n\n
<\/span>Resource Exhaustion<\/span><\/h2>\n\n\n\n
What do we do when an attempt to acquire a resource fails?  Two choices:<\/p>\n\n\n\n
    \n
  • Termination<\/em><\/strong>:<\/em>  Abandon the computation and return to some caller.\n
      \n
    • Termination<\/em> is in most cases far simpler, and allows a system to maintain a better separation of levels of abstraction.  (Note that termination means only termination of the computation, not necessarily the program.)<\/li>\n<\/ul>\n<\/li>\n\n\n\n
    • Resumption<\/em><\/strong>:<\/em>  Ask the caller to fix the problem and continue.<\/li>\n<\/ul>\n\n\n\n
      In C++:<\/p>\n\n\n\n