{"id":6866,"date":"2024-02-07T11:18:02","date_gmt":"2024-02-07T17:18:02","guid":{"rendered":"https:\/\/www.logikalsolutions.com\/wordpress\/?p=6866"},"modified":"2024-02-08T16:42:41","modified_gmt":"2024-02-08T22:42:41","slug":"delete","status":"publish","type":"post","link":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/","title":{"rendered":"C++ \u2013 Defaults and Deletes \u2013 Pt. 3"},"content":{"rendered":"\n

In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is that the default deconstructor does basically nothing. Near Heap allocations are reclaimed automatically when you return from a method\/function. For Far Heap objects all it does is free the allocation. It will not free any sub allocations. You have already been shown the code for the ImplicitClass so we will not discuss it again.<\/p>\n\n\n\n

NoFarHeap.h<\/h2>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/*<\/span><\/span>\n * nearheapclass.h<\/span><\/span>\n *<\/span><\/span>\n *  Created on: Feb 1, 2024<\/span><\/span>\n *      Author: roland<\/span><\/span>\n *\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> NOFARHEAP_H_<\/span><\/span>\n#define<\/span> NOFARHEAP_H_<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><optional><\/span><\/span>\n<\/span>\nclass<\/span> NoFarHeap<\/span><\/span>\n{<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n\tNoFarHeap() <\/span>=<\/span> <\/span>default<\/span>;<\/span><\/span>\n\t<\/span>explicit<\/span> NoFarHeap( <\/span>int<\/span> i<\/span>,<\/span><\/span>\n\t\t\t\t\t\t\tstd<\/span>::<\/span>optional<<\/span>double<\/span>> dbl <\/span>=<\/span> std<\/span>::<\/span>nullopt<\/span>,<\/span><\/span>\n\t\t\t\t\t\t\tstd<\/span>::<\/span>optional<<\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span>> txt <\/span>=<\/span> std<\/span>::<\/span>nullopt);<\/span><\/span>\n<\/span>\n\tNoFarHeap( <\/span>const<\/span> NoFarHeap <\/span>&<\/span>other) <\/span>=<\/span> <\/span>default<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>virtual<\/span> ~NoFarHeap() <\/span>=<\/span> <\/span>default<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>int<\/span> get_int();<\/span><\/span>\n\t<\/span>double<\/span> get_dbl();<\/span><\/span>\n\t<\/span>char<\/span> <\/span>*<\/span>get_buffer();<\/span><\/span>\n<\/span>\n\t<\/span>void<\/span> set_int( <\/span>int<\/span> i);<\/span><\/span>\n\t<\/span>void<\/span> set_dbl( <\/span>double<\/span> d);<\/span><\/span>\n\t<\/span>void<\/span> set_buffer_content( <\/span>char<\/span> <\/span>*<\/span>txt);<\/span><\/span>\n<\/span>\nprivate<\/span>:<\/span><\/span>\n\t<\/span>int<\/span>\t\tm_int {<\/span>25<\/span>};<\/span><\/span>\n\t<\/span>double<\/span>\tm_dbl {<\/span>3.14159<\/span>};<\/span>\t\/\/ yes, I used PI<\/span><\/span>\n\t<\/span>char<\/span>\t<\/span>m_buffer<\/span>[<\/span>2048<\/span>] {<\/span>'\\0'<\/span>};<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* NOFARHEAP_H_ *\/<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
I called this class NoFarHeap because it has no dynamic memory allocations. We took the compiler defaults for the default and copy constructor. If you read this post on std::optional<\/a> then you recognize the only constructor I coded. The benefit of std::optional is it allows you to skip over parameters without knowing their default values and without having to have the coded in many places. It has drawbacks though.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
NoFarHeap abc( <\/span>32<\/span>,<\/span> std<\/span>::<\/span>nullopt<\/span>,<\/span> <\/span>"I want this text first"<\/span>);<\/span><\/span>\n<\/span>\nNoFarHeap def( <\/span>27<\/span>);<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
When the most frequent use case is just changing the first parameter of the class constructor, std::nullopt works great for the rest. As you can see, it is just cumbersome when you want to change first and last.<\/p>\n\n\n\n
In case you do not know, at line 36, we declare m_buffer and initialize the entire thing to nulls. For this class I also allow the unsafe practice of returning the actual m_buffer pointer.<\/p>\n\n\n\n
NearHeapClass.cpp<\/h2>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/*<\/span><\/span>\n * nearheapclass.cpp<\/span><\/span>\n *<\/span><\/span>\n *  Created on: Feb 1, 2024<\/span><\/span>\n *      Author: roland<\/span><\/span>\n *\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"nofarheap.h"<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><cstring><\/span><\/span>\n<\/span>\n<\/span>\nNoFarHeap<\/span>::<\/span>NoFarHeap(<\/span>int<\/span> i<\/span>,<\/span> std<\/span>::<\/span>optional<\/span><double><\/span> dbl<\/span>,<\/span> std<\/span>::<\/span>optional<\/span><const<\/span> <\/span>char<\/span> <\/span>*><\/span> txt) :<\/span><\/span>\n\t\tm_int(i)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> (<\/span>dbl<\/span>.<\/span>has_value())<\/span><\/span>\n\t{<\/span><\/span>\n\t\tm_dbl <\/span>=<\/span> <\/span>dbl<\/span>.<\/span>value();<\/span><\/span>\n\t}<\/span><\/span>\n<\/span>\n\t<\/span>if<\/span> (<\/span>txt<\/span>.<\/span>has_value())<\/span><\/span>\n\t{<\/span><\/span>\n\t\tstrncpy( m_buffer<\/span>,<\/span> <\/span>txt<\/span>.<\/span>value()<\/span>,<\/span> <\/span>sizeof<\/span>(m_buffer)<\/span>-<\/span>1<\/span>);<\/span><\/span>\n\t}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> NoFarHeap<\/span>::<\/span>get_int()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>return<\/span> (m_int);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\ndouble<\/span> NoFarHeap<\/span>::<\/span>get_dbl()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>return<\/span> (m_dbl);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nchar<\/span> <\/span>*<\/span>NoFarHeap<\/span>::<\/span>get_buffer()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>return<\/span> (m_buffer);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> NoFarHeap<\/span>::<\/span>set_int(<\/span>int<\/span> i)<\/span><\/span>\n{<\/span><\/span>\n\tm_int <\/span>=<\/span> i;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> NoFarHeap<\/span>::<\/span>set_dbl(<\/span>double<\/span> d)<\/span><\/span>\n{<\/span><\/span>\n\tm_dbl <\/span>=<\/span> d;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> NoFarHeap<\/span>::<\/span>set_buffer_content(<\/span>char<\/span> <\/span>*<\/span>txt)<\/span><\/span>\n{<\/span><\/span>\n\tstrncpy( m_buffer<\/span>,<\/span> txt<\/span>,<\/span> <\/span>sizeof<\/span>(m_buffer)<\/span>-<\/span>1<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Only thing worthy of note here is line 23 where we copy<\/em> the text into buffer instead of changing the pointer.<\/p>\n\n\n\n
FarHeapClass.h<\/h2>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/*<\/span><\/span>\n * dynamicclass.h<\/span><\/span>\n *<\/span><\/span>\n *  Created on: Feb 1, 2024<\/span><\/span>\n *      Author: roland<\/span><\/span>\n *\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> FARHEAPCLASS_H_<\/span><\/span>\n#define<\/span> FARHEAPCLASS_H_<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><string><\/span><\/span>\n<\/span>\nclass<\/span> FarHeapClass<\/span><\/span>\n{<\/span><\/span>\npublic<\/span>:<\/span><\/span>\n\t<\/span>explicit<\/span> FarHeapClass(<\/span>int<\/span> portNumber <\/span>=<\/span> <\/span>1<\/span>,<\/span> <\/span>int<\/span> bufferSize <\/span>=<\/span> <\/span>2048<\/span>);<\/span><\/span>\n\tFarHeapClass(<\/span>const<\/span> FarHeapClass <\/span>&<\/span>other) <\/span>=<\/span> <\/span>delete<\/span>;<\/span><\/span>\n\t<\/span>virtual<\/span> ~FarHeapClass();<\/span><\/span>\n<\/span>\n\t<\/span>int<\/span> buffer_size();<\/span><\/span>\n\t<\/span>int<\/span> port_number();<\/span><\/span>\n<\/span>\n\t<\/span>void<\/span> fake_read_from_port();<\/span><\/span>\n<\/span>\n\tstd<\/span>::<\/span>string buffer_content();<\/span><\/span>\n<\/span>\n\tFarHeapClass<\/span>&<\/span> <\/span>operator<\/span>=(<\/span>const<\/span> FarHeapClass<\/span>&<\/span>) <\/span>=<\/span> <\/span>delete<\/span>;<\/span><\/span>\n<\/span>\nprivate<\/span>:<\/span><\/span>\n\t<\/span>int<\/span> m_buffer_size;<\/span><\/span>\n\t<\/span>int<\/span> m_port_number;<\/span><\/span>\n\t<\/span>char<\/span> <\/span>*<\/span>m_buffer {};<\/span><\/span>\n<\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* FARHEAPCLASS_H_ *\/<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Pay close attention to line 17. I delete the copy constructor. Why did I do that? Line 32. This class dynamically allocates its buffer. It is also why line 27 deletes the assignment operator. <\/p>\n\n\n\n
You should also pay attention to line 18. There is a growing academic trend of wanting all destructors to be declared virtual. I’m not on board with it<\/em>, but it is a growing trend. The “philosophy” is that if someone derives a class from yours and is passing things around via a base class pointer then does a <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
delete<\/span> ptr;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Only the base class destructor will be called\/used. Putting virtual on the destructor forces the compiler to look up the actual class type and call the correct destructor.<\/p>\n\n\n\n
FarHeapClass.cpp<\/h2>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/*<\/span><\/span>\n * dynamicclass.cpp<\/span><\/span>\n *<\/span><\/span>\n *  Created on: Feb 1, 2024<\/span><\/span>\n *      Author: roland<\/span><\/span>\n *\/<\/span><\/span>\n#include<\/span> <\/span><cstring><\/span><\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"farheapclass.h"<\/span><\/span>\n<\/span>\nFarHeapClass<\/span>::<\/span>FarHeapClass(<\/span>int<\/span> portNumber<\/span>,<\/span> <\/span>int<\/span> bufferSize) :<\/span><\/span>\n  m_port_number(portNumber)<\/span>,<\/span><\/span>\n  m_buffer_size(bufferSize)<\/span><\/span>\n{<\/span><\/span>\n\tm_buffer <\/span>=<\/span> <\/span>new<\/span> <\/span>char<\/span> [ m_buffer_size];<\/span><\/span>\n\tmemset( m_buffer<\/span>,<\/span> <\/span>'\\0'<\/span>,<\/span> m_buffer_size);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nFarHeapClass<\/span>::<\/span>~<\/span>FarHeapClass()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> (m_buffer <\/span>!=<\/span> <\/span>nullptr<\/span>)<\/span><\/span>\n\t{<\/span><\/span>\n\t\t<\/span>delete<\/span> m_buffer;<\/span><\/span>\n\t\tm_buffer <\/span>=<\/span> <\/span>nullptr<\/span>;<\/span>  \/\/ I like to do this just in case though it shouldn't matter<\/span><\/span>\n\t}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> FarHeapClass<\/span>::<\/span>buffer_size()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>return<\/span> (m_buffer_size);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> FarHeapClass<\/span>::<\/span>port_number()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>return<\/span> (m_port_number);<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nstd<\/span>::<\/span>string FarHeapClass<\/span>::<\/span>buffer_content()<\/span><\/span>\n{<\/span><\/span>\n\tstd<\/span>::<\/span>string str(m_buffer);<\/span><\/span>\n\t<\/span>return<\/span> (str);<\/span>  \/\/ returned by value<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> FarHeapClass<\/span>::<\/span>fake_read_from_port()<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> (m_buffer <\/span>!=<\/span> <\/span>nullptr<\/span>)<\/span><\/span>\n\t{<\/span><\/span>\n\t\tstd<\/span>::<\/span>string some_text;<\/span><\/span>\n\t\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"=========== Please enter some text: "<\/span>;<\/span><\/span>\n\t\tstd<\/span>::<\/span>getline( std<\/span>::<\/span>cin<\/span>,<\/span> some_text);<\/span><\/span>\n<\/span>\n\t\tstrncpy(m_buffer<\/span>,<\/span> <\/span>some_text<\/span>.<\/span>c_str()<\/span>,<\/span> m_buffer_size<\/span>-<\/span>1<\/span>);<\/span><\/span>\n\t}<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Lines 16 and 17 are where we allocate our buffer and null it out. You will note that I do not let users get direct access to the buffer. Here we return a string.<\/p>\n\n\n\n
While this class may seem hokey, I modeled it after many I’ve had to do in the embedded systems world. Usually for serial, but any other kind of port I\/O. I just didn’t muddy the class up with platform specific port I\/O code. <\/p>\n\n\n\n
DefaultsAndDeletes.cpp<\/h2>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"config.h"<\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"implicitclass.h"<\/span><\/span>\n#include<\/span> <\/span>"nofarheap.h"<\/span><\/span>\n#include<\/span> <\/span>"farheapclass.h"<\/span><\/span>\n<\/span>\nvoid<\/span> dump_implicit( std<\/span>::<\/span>string label<\/span>,<\/span> ImplicitClass <\/span>&<\/span>ic)<\/span><\/span>\n{<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> label <\/span><<<\/span> <\/span>"   fred: "<\/span> <\/span><<<\/span> <\/span>ic<\/span>.<\/span>fred <\/span><<<\/span> <\/span>"  ethyl: "<\/span> <\/span><<<\/span> <\/span>ic<\/span>.<\/span>ethyl<\/span><\/span>\n\t\t\t  <\/span><<<\/span> <\/span>"  status: "<\/span> <\/span><<<\/span> <\/span>ic<\/span>.<\/span>statusStr <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n<\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> dump_noFarHeapClass( std<\/span>::<\/span>string label<\/span>,<\/span> NoFarHeap <\/span>*<\/span>ptr)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> (ptr <\/span>!=<\/span> <\/span>nullptr<\/span>)<\/span><\/span>\n\t{<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"** "<\/span> <\/span><<<\/span> label <\/span><<<\/span> <\/span>"  int: "<\/span> <\/span><<<\/span> <\/span>ptr<\/span>-><\/span>get_int()<\/span><\/span>\n\t\t\t  <\/span><<<\/span> <\/span>"  dbl: "<\/span> <\/span><<<\/span> <\/span>ptr<\/span>-><\/span>get_dbl()<\/span><\/span>\n\t\t\t  <\/span><<<\/span> <\/span>"  buffer: "<\/span> <\/span><<<\/span> <\/span>ptr<\/span>-><\/span>get_buffer() <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\t}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nvoid<\/span> dump_farHeapClass( std<\/span>::<\/span>string label<\/span>,<\/span> FarHeapClass <\/span>*<\/span>ptr)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> (ptr <\/span>!=<\/span> <\/span>nullptr<\/span>)<\/span><\/span>\n\t{<\/span><\/span>\n\t\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"-- "<\/span> <\/span><<<\/span> label <\/span><<<\/span> <\/span>"  buffer_size: "<\/span> <\/span><<<\/span><\/span>\n\t\t\t\t<\/span>ptr<\/span>-><\/span>buffer_size() <\/span><<<\/span> <\/span>"  port_number: "<\/span> <\/span><<<\/span><\/span>\n\t\t\t\t<\/span>ptr<\/span>-><\/span>port_number() <\/span><<<\/span> <\/span>"  content: "<\/span> <\/span><<<\/span><\/span>\n\t\t\t\t<\/span>ptr<\/span>-><\/span>buffer_content() <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\t}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> main(<\/span>int<\/span> argc<\/span>,<\/span> <\/span>char<\/span> <\/span>**<\/span>argv) {<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"DefaultsAndDeletes"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"Version "<\/span> <\/span><<<\/span> DefaultsAndDeletes_VERSION_MAJOR <\/span><<<\/span> <\/span>"."<\/span> <\/span><<<\/span> DefaultsAndDeletes_VERSION_MINOR <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>";;;;;;;;;;;;;;;;;;;"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"            Implicit Class Examples"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>";;;;;;;;;;;;;;;;;;;"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n<\/span>\n\tImplicitClass lucy;<\/span><\/span>\n\tdump_implicit( <\/span>"lucy"<\/span>,<\/span> lucy);<\/span><\/span>\n<\/span>\n\tImplicitClass young {<\/span>8<\/span>,<\/span> <\/span>9.6<\/span>,<\/span> <\/span>"kids next door"<\/span>};<\/span><\/span>\n\tdump_implicit( <\/span>"young"<\/span>,<\/span> young);<\/span><\/span>\n<\/span>\n\tImplicitClass ricki {lucy};<\/span><\/span>\n\tlucy <\/span>=<\/span> young;<\/span>\t\/\/ be young again<\/span><\/span>\n<\/span>\n\tdump_implicit( <\/span>"second lucy"<\/span>,<\/span> lucy);<\/span><\/span>\n\tdump_implicit( <\/span>"ricky"<\/span>,<\/span> ricki);<\/span><\/span>\n<\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>";;;;;;;;;;;;;;;;;;;"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"            NoFarHeap Class Examples"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>";;;;;;;;;;;;;;;;;;;"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n<\/span>\n\t\/\/ this class doesn't dynamically allocate anything<\/span><\/span>\n\t\/\/<\/span><\/span>\n\tNoFarHeap firstVar;<\/span><\/span>\n\tdump_noFarHeapClass( <\/span>"firstVar: "<\/span>,<\/span> <\/span>&<\/span>firstVar);<\/span><\/span>\n<\/span>\n\tNoFarHeap secondVar(<\/span>32767<\/span>,<\/span> <\/span>98.5<\/span>);<\/span><\/span>\n\tdump_noFarHeapClass( <\/span>"secondVar: "<\/span>,<\/span> <\/span>&<\/span>secondVar);<\/span><\/span>\n<\/span>\n\t\/\/ just because it doesn't use the heap doesn't mean it cannot be on<\/span><\/span>\n\t\/\/ the heap<\/span><\/span>\n\t\/\/<\/span><\/span>\n\tNoFarHeap <\/span>*<\/span>thirdVar <\/span>=<\/span> <\/span>new<\/span> NoFarHeap(<\/span>747<\/span>,<\/span> <\/span>3.33333<\/span>,<\/span> <\/span>"Don't fly MAX"<\/span>);<\/span><\/span>\n\tdump_noFarHeapClass( <\/span>"thirdVar: "<\/span>,<\/span> thirdVar);<\/span><\/span>\n<\/span>\n\t<\/span>*<\/span>thirdVar <\/span>=<\/span> secondVar;<\/span><\/span>\n\tdump_noFarHeapClass( <\/span>"thirdVar after assignment: "<\/span>,<\/span> thirdVar);<\/span><\/span>\n<\/span>\n\tNoFarHeap fourthVar( <\/span>*<\/span>thirdVar);<\/span><\/span>\n\tdump_noFarHeapClass( <\/span>"fourthVar: "<\/span>,<\/span> <\/span>&<\/span>fourthVar);<\/span><\/span>\n<\/span>\n\t<\/span>delete<\/span> thirdVar;<\/span><\/span>\n<\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>";;;;;;;;;;;;;;;;;;;"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"            FarHeapClass Examples"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> <\/span>";;;;;;;;;;;;;;;;;;;"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n<\/span>\n\tFarHeapClass h1;<\/span><\/span>\n\tdump_farHeapClass( <\/span>"Default constructor: "<\/span>,<\/span> <\/span>&<\/span>h1);<\/span><\/span>\n<\/span>\n\tFarHeapClass <\/span>*<\/span>hp1 <\/span>=<\/span> <\/span>new<\/span> FarHeapClass( <\/span>2<\/span>,<\/span> <\/span>36000<\/span>);<\/span><\/span>\n\t<\/span>hp1<\/span>-><\/span>fake_read_from_port();<\/span><\/span>\n\tdump_farHeapClass( <\/span>"After faking read: "<\/span>,<\/span> hp1);<\/span><\/span>\n<\/span>\n\t<\/span>delete<\/span> hp1;<\/span><\/span>\n<\/span>\n\tstd<\/span>::<\/span>cout <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> std<\/span>::<\/span>endl <\/span><<<\/span> <\/span>"finished"<\/span> <\/span><<<\/span> std<\/span>::<\/span>endl;<\/span><\/span>\n<\/span>\n\t<\/span>return<\/span> (<\/span>0<\/span>);<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Discussion<\/h2>\n\n\n\n
We will start our discussion at line 72 of the main module. Just because I called the class NoFarHeap doesn’t mean I can’t create one on the far heap via new.<\/p>\n\n\n\n
Lines 81 and 95 where I delete the things I create need to be discussed. In fact, I’m going to re-use an image.<\/p>\n\n\n
\n
\"\"<\/figure>\n<\/div>\n\n\n
You are responsible for deleting everything you create. I work in the embedded systems world where we can’t let things consume memory because our stuff runs for weeks on end. I can also tell you that first bullet point is basically bullshit. If you are on OpenVMS or a mainframe it is true of every program no matter the language. Those platforms originated for time sharing and their accounting systems keeps track of every byte of RAM.<\/p>\n\n\n\n
On the weaker feebler x86, Arm, etc. platforms, the operating systems are not robust. What they define as a process is too light to even be a thread on a real platform. When you allocate stuff inside threads or lambdas don’t expect it to go away when you exit. <\/p>\n\n\n\n
Application Frameworks<\/h3>\n\n\n\n
I’ve written about Qt<\/a> many times on here. I’ve pointed you to CopperSpice<\/a> and wxWidgets<\/a> as well. One of the big draws to these frameworks was garbage collection. Told you that in this post<\/a>. Too many programmers were too lazy (or unskilled) when it came to memory management. They just assumed the operating system would take care of it and the machine ran slower and slower until it crashed. (Remind you of Microsoft?)<\/p>\n\n\n\n
I ranted and ragged for years that the academics on the C++ standards committee needed to “fix new.” I wanted it to keep track of each allocation by file and line and timestamp when a program was compiled with debug and to print out a nice list of all things left not freed when execution ended. The academics never got around to it. They were more focused on doing stupid things like mandating 2’s complement for integer storage when Unysis mainframes (the ones used by the IRS and many other large financial institutions) are 1’s complement.<\/p>\n\n\n\n
Industry got tired of waiting for academics to get a clue, it created AddressSanitizer<\/a>. It got rolled into GNU and many other compilers around the time of Ubuntu 12.04. You can read more about it here<\/a> and here<\/a>. Some things you might want to keep handy for your CMake scripts.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
 CFLAGS += -fsanitize=address -fno-omit-frame-pointer<\/span><\/span>\n CXXFLAGS += -fsanitize=address -fno-omit-frame-pointer<\/span><\/span>\n LDFLAGS += -fno-omit-frame-pointer -fsanitize=address<\/span><\/span>\n ASAN_OPTIONS=strict_string_checks=1:detect_stack_use_after_return=1:check_initialization_order=1:strict_init_order=1 <\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Summary<\/h2>\n\n\n\n
When you have a very simple class like our ImplicitClass and NoFarHeap classes, take the defaults. It’s best to be explicit about them as we were in NoFarHeap<\/em>. Everybody goes through that “I memorized the language standard” phase of coding, then they learn what it is to have a life and stop memorizing the language standard.<\/p>\n\n\n\n
Any time you have a class that dynamically allocates something which must be freed in the destructor be certain to delete the copy constructor!<\/strong> If you don’t you will end up with a dual delete\/free at runtime. If you think “smart pointers” will “solve” the issue for you read this post<\/a>.<\/p>\n\n\n\n
Making your destructor virtual does make it easier for someone to use it as a base class passing all of the classes they derived from it around via a base class pointer. It also adds vtable entries and overhead to the class at run-time. Unless you are an application framework created in the early 1990s basing all of your objects off something like QObject so you can ensure object deletion . . . should you really be doing that<\/strong>? This is 2024. We shouldn’t be cheating like that anymore, not without a damned good reason. In the 1990s we had to because neither the language nor the industry had tools like AddressSanitizer.<\/p>\n\n\n\n
I’m not a fan of Template Metaprogramming<\/a>, but it has its place. Most modern-ish C++ frameworks are going the route of making all containers templates so instead of having to use a QObject generic pointer the compiler spins up a customer container class for your object. Remember: STL == Standard Template Library.<\/p>\n\n\n\n
Above all else remember that a default destructor does nothing. It’s just a free of the memory within your class object, not anything it allocated.<\/p>\n","protected":false},"excerpt":{"rendered":"
In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is that the default deconstructor does basically nothing. Near Heap allocations are reclaimed automatically when you return from a method\/function. For Far Heap objects all it does is free the allocation. It will not free any sub allocations. You have already been shown the code for the ImplicitClass so we will not … C++ \u2013 Defaults and Deletes \u2013 Pt. 3<\/span>Read more<\/a><\/p>\n","protected":false},"author":2,"featured_media":6848,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[3],"tags":[1504],"class_list":["post-6866","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-information-technology","tag-c","bnm-entry"],"yoast_head":"\nC++ \u2013 Defaults and Deletes \u2013 Pt. 3 – Logikal Blog<\/title>\n<meta name=\"description\" content=\"In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is . . .\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"C++ \u2013 Defaults and Deletes \u2013 Pt. 3 – Logikal Blog\" \/>\n<meta property=\"og:description\" content=\"In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is . . .\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/\" \/>\n<meta property=\"og:site_name\" content=\"Logikal Blog\" \/>\n<meta property=\"article:published_time\" content=\"2024-02-07T17:18:02+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2024-02-08T22:42:41+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2024\/02\/cpp-icon.png\" \/>\n\t<meta property=\"og:image:width\" content=\"256\" \/>\n\t<meta property=\"og:image:height\" content=\"288\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/png\" \/>\n<meta name=\"author\" content=\"seasoned_geek\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"seasoned_geek\" \/>\n\t<meta name=\"twitter:label2\" content=\"Est. reading time\" \/>\n\t<meta name=\"twitter:data2\" content=\"7 minutes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\\\/\\\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/\"},\"author\":{\"name\":\"seasoned_geek\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"headline\":\"C++ \u2013 Defaults and Deletes \u2013 Pt. 3\",\"datePublished\":\"2024-02-07T17:18:02+00:00\",\"dateModified\":\"2024-02-08T22:42:41+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/\"},\"wordCount\":1159,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"image\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2024\\\/02\\\/cpp-icon.png\",\"keywords\":[\"C++\"],\"articleSection\":[\"Information Technology\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/\",\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/\",\"name\":\"C++ \u2013 Defaults and Deletes \u2013 Pt. 3 – Logikal Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2024\\\/02\\\/cpp-icon.png\",\"datePublished\":\"2024-02-07T17:18:02+00:00\",\"dateModified\":\"2024-02-08T22:42:41+00:00\",\"description\":\"In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is . . .\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2024\\\/02\\\/cpp-icon.png\",\"contentUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2024\\\/02\\\/cpp-icon.png\",\"width\":256,\"height\":288,\"caption\":\"C++ image from icons-library.com\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/delete\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"C++ \u2013 Defaults and Deletes \u2013 Pt. 3\"}]},{\"@type\":\"WebSite\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#website\",\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/\",\"name\":\"Logikal Blog\",\"description\":\"For people with attention spans longer than a Tweet\",\"publisher\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":[\"Person\",\"Organization\"],\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\",\"name\":\"seasoned_geek\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r\",\"url\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r\",\"contentUrl\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r\",\"caption\":\"seasoned_geek\"},\"logo\":{\"@id\":\"https:\\\/\\\/secure.gravatar.com\\\/avatar\\\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r\"},\"description\":\"Roland Hughes started his IT career in the early 1980s. He quickly became a consultant and president of Logikal Solutions, a software consulting firm specializing in OpenVMS application and C++\\\/Qt touchscreen\\\/embedded Linux development. Early in his career he became involved in what is now called cross platform development. Given the dearth of useful books on the subject he ventured into the world of professional author in 1995 writing the first of the \\\"Zinc It!\\\" book series for John Gordon Burke Publisher, Inc. A decade later he released a massive (nearly 800 pages) tome \\\"The Minimum You Need to Know to Be an OpenVMS Application Developer\\\" which tried to encapsulate the essential skills gained over what was nearly a 20 year career at that point. From there \\\"The Minimum You Need to Know\\\" book series was born. Three years later he wrote his first novel \\\"Infinite Exposure\\\" which got much notice from people involved in the banking and financial security worlds. Some of the attacks predicted in that book have since come to pass. While it was not originally intended to be a trilogy, it became the first book of \\\"The Earth That Was\\\" trilogy: Infinite Exposure Lesedi - The Greatest Lie Ever Told John Smith - Last Known Survivor of the Microsoft Wars When he is not consulting Roland Hughes posts about technology and sometimes politics on his blog. He also has regularly scheduled Sunday posts appearing on the Interesting Authors blog.\",\"sameAs\":[\"https:\\\/\\\/theminimumyouneedtoknow.com\"],\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/author\\\/seasoned_geek\\\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"C++ \u2013 Defaults and Deletes \u2013 Pt. 3 – Logikal Blog","description":"In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is . . .","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/","og_locale":"en_US","og_type":"article","og_title":"C++ \u2013 Defaults and Deletes \u2013 Pt. 3 – Logikal Blog","og_description":"In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is . . .","og_url":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/","og_site_name":"Logikal Blog","article_published_time":"2024-02-07T17:18:02+00:00","article_modified_time":"2024-02-08T22:42:41+00:00","og_image":[{"width":256,"height":288,"url":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2024\/02\/cpp-icon.png","type":"image\/png"}],"author":"seasoned_geek","twitter_card":"summary_large_image","twitter_misc":{"Written by":"seasoned_geek","Est. reading time":"7 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#article","isPartOf":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/"},"author":{"name":"seasoned_geek","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"headline":"C++ \u2013 Defaults and Deletes \u2013 Pt. 3","datePublished":"2024-02-07T17:18:02+00:00","dateModified":"2024-02-08T22:42:41+00:00","mainEntityOfPage":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/"},"wordCount":1159,"commentCount":0,"publisher":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"image":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#primaryimage"},"thumbnailUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2024\/02\/cpp-icon.png","keywords":["C++"],"articleSection":["Information Technology"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/","url":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/","name":"C++ \u2013 Defaults and Deletes \u2013 Pt. 3 – Logikal Blog","isPartOf":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#primaryimage"},"image":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#primaryimage"},"thumbnailUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2024\/02\/cpp-icon.png","datePublished":"2024-02-07T17:18:02+00:00","dateModified":"2024-02-08T22:42:41+00:00","description":"In this installment for Defaults and Deletes we finish the code for the example program. So far, among the things you have learned is . . .","breadcrumb":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#primaryimage","url":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2024\/02\/cpp-icon.png","contentUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2024\/02\/cpp-icon.png","width":256,"height":288,"caption":"C++ image from icons-library.com"},{"@type":"BreadcrumbList","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/delete\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.logikalsolutions.com\/wordpress\/"},{"@type":"ListItem","position":2,"name":"C++ \u2013 Defaults and Deletes \u2013 Pt. 3"}]},{"@type":"WebSite","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#website","url":"https:\/\/www.logikalsolutions.com\/wordpress\/","name":"Logikal Blog","description":"For people with attention spans longer than a Tweet","publisher":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https:\/\/www.logikalsolutions.com\/wordpress\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":["Person","Organization"],"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842","name":"seasoned_geek","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/secure.gravatar.com\/avatar\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r","url":"https:\/\/secure.gravatar.com\/avatar\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r","caption":"seasoned_geek"},"logo":{"@id":"https:\/\/secure.gravatar.com\/avatar\/ae9adac14079d84b909e635d7af986fe4568053af4fd9ff8d4109298c392493e?s=96&d=mm&r=r"},"description":"Roland Hughes started his IT career in the early 1980s. He quickly became a consultant and president of Logikal Solutions, a software consulting firm specializing in OpenVMS application and C++\/Qt touchscreen\/embedded Linux development. Early in his career he became involved in what is now called cross platform development. Given the dearth of useful books on the subject he ventured into the world of professional author in 1995 writing the first of the \"Zinc It!\" book series for John Gordon Burke Publisher, Inc. A decade later he released a massive (nearly 800 pages) tome \"The Minimum You Need to Know to Be an OpenVMS Application Developer\" which tried to encapsulate the essential skills gained over what was nearly a 20 year career at that point. From there \"The Minimum You Need to Know\" book series was born. Three years later he wrote his first novel \"Infinite Exposure\" which got much notice from people involved in the banking and financial security worlds. Some of the attacks predicted in that book have since come to pass. While it was not originally intended to be a trilogy, it became the first book of \"The Earth That Was\" trilogy: Infinite Exposure Lesedi - The Greatest Lie Ever Told John Smith - Last Known Survivor of the Microsoft Wars When he is not consulting Roland Hughes posts about technology and sometimes politics on his blog. He also has regularly scheduled Sunday posts appearing on the Interesting Authors blog.","sameAs":["https:\/\/theminimumyouneedtoknow.com"],"url":"https:\/\/www.logikalsolutions.com\/wordpress\/author\/seasoned_geek\/"}]}},"_links":{"self":[{"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/posts\/6866","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/users\/2"}],"replies":[{"embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/comments?post=6866"}],"version-history":[{"count":0,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/posts\/6866\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/media\/6848"}],"wp:attachment":[{"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/media?parent=6866"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/categories?post=6866"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/tags?post=6866"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}