{"id":6303,"date":"2023-11-05T08:23:45","date_gmt":"2023-11-05T14:23:45","guid":{"rendered":"https:\/\/www.logikalsolutions.com\/wordpress\/?p=6303"},"modified":"2023-11-27T17:28:15","modified_gmt":"2023-11-27T23:28:15","slug":"stdlist","status":"publish","type":"post","link":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/","title":{"rendered":"std::list – Example and Explanation"},"content":{"rendered":"\n

Our discussion of std::list, like our discussion of std::vector<\/a> will start with a bit of history. It wasn’t until the IT industry was inundated with tiny x86 minds<\/a> that people “tried to do it all in RAM.” Before the PC we had real computers with real operating systems. Other than Assembler, our languages were robust. Every platform supported indexed files and so did the compiler for every language. When we needed a multiply linked list we did something like the following.<\/p>\n\n\n\n

VAX BASIC<\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
! <\/span>VAX<\/span> <\/span>BASIC<\/span><\/span>\n<\/span>\n        <\/span>WHEN<\/span> <\/span>ERROR<\/span> <\/span>IN<\/span><\/span>\n            <\/span>L_ERR<\/span>% = <\/span>0<\/span>%<\/span><\/span>\n            <\/span>OPEN<\/span> <\/span>drawing_stats$<\/span> <\/span>FOR<\/span> <\/span>OUTPUT<\/span> <\/span>AS<\/span> <\/span>FILE<\/span> #<\/span>dstat_chan<\/span>%,    &<\/span><\/span>\n                <\/span>ORGANIZATION<\/span> <\/span>INDEXED<\/span> <\/span>FIXED<\/span>,                         &<\/span><\/span>\n                <\/span>ALLOW<\/span> <\/span>NONE<\/span>,                                         &<\/span><\/span>\n                <\/span>RECORDTYPE<\/span> <\/span>FORTRAN<\/span>,                                 &<\/span><\/span>\n                <\/span>RECORDSIZE<\/span> <\/span>zillionare_stats_record_size<\/span>,            &<\/span><\/span>\n                <\/span>PRIMARY<\/span> <\/span>KEY<\/span> <\/span>D_STAT<\/span>::<\/span>ELM_NO<\/span>,                         &<\/span><\/span>\n\t\t<\/span>MAP<\/span> <\/span>D_STAT_MAP<\/span><\/span>\n        <\/span>USE<\/span><\/span>\n            <\/span>L_ERR<\/span>% = <\/span>ERR<\/span><\/span>\n            <\/span>PRINT<\/span> <\/span>"Unable to open drawing stat output file"<\/span>; <\/span>drawing_stats$<\/span><\/span>\n            <\/span>PRINT<\/span> <\/span>"Error: "<\/span>;<\/span>L_ERR<\/span>%;<\/span>" "<\/span>;<\/span>ERT$<\/span>( <\/span>L_ERR<\/span>%)<\/span><\/span>\n        <\/span>END<\/span> <\/span>WHEN<\/span><\/span>\n<\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
DIBOL (DIgital’s Business Oriented Language)<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    ;-----<\/span><\/span>\n    ;   <\/span>This<\/span> <\/span>is<\/span> <\/span>DIBOL<\/span><\/span>\n    ;-----<\/span><\/span>\n<\/span>\n    <\/span>if<\/span> (.<\/span>NOT<\/span>. <\/span>file_err_flg<\/span>)<\/span><\/span>\n    <\/span>begin<\/span><\/span>\n        <\/span>try<\/span><\/span>\n            <\/span>open<\/span>( <\/span>mega_stat_chan<\/span>=%<\/span>syn_freechn<\/span>,<\/span><\/span>\n            & <\/span>o<\/span>:<\/span>i<\/span>, <\/span><\/span>\n            & <\/span>MSTAT_FILE_NAME<\/span> ,<\/span><\/span>\n            & <\/span>FDL<\/span>:<\/span>"@MEGA_DAT:MEGA_STATS.FDL"<\/span> ,<\/span><\/span>\n            & <\/span>RECTYPE<\/span>:<\/span>1<\/span>)<\/span><\/span>\n    <\/span><\/span>\n        <\/span>catch<\/span> (<\/span>e<\/span>, @<\/span>Exception<\/span>)<\/span><\/span>\n         <\/span>begin<\/span><\/span>\n            <\/span>l_x<\/span> = %<\/span>SYSERR<\/span><\/span>\n            <\/span>writes<\/span>( <\/span>tt<\/span>, %<\/span>string<\/span>( <\/span>l_x<\/span>) + <\/span><\/span>\n            &       <\/span>" result trying to open "<\/span> + <\/span>MSTAT_FILE_NAME<\/span> )<\/span><\/span>\n            <\/span>close<\/span>( <\/span>mega_chan<\/span>)<\/span><\/span>\n            <\/span>file_err_flg<\/span> = %<\/span>TRUE<\/span><\/span>\n            <\/span>eof_flg<\/span> = %<\/span>TRUE<\/span><\/span>\n         <\/span>end<\/span><\/span>\n        <\/span>endtry<\/span><\/span>\n    <\/span>end<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
COBOL<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
*  COBOL<\/span><\/span>\n...<\/span><\/span>\nFILE-CONTROL<\/span>.<\/span><\/span>\n<\/span>\n<\/span>\n    <\/span>SELECT<\/span> DRAW-STATS<\/span><\/span>\n        <\/span>ASSIGN<\/span> <\/span>TO<\/span> <\/span>'DRAWING_STATS'<\/span><\/span>\n        <\/span>ORGANIZATION<\/span> <\/span>IS<\/span> <\/span>INDEXED<\/span><\/span>\n        <\/span>ACCESS<\/span> <\/span>MODE<\/span> <\/span>IS<\/span> <\/span>RANDOM<\/span><\/span>\n        <\/span>RECORD KEY<\/span> <\/span>IS<\/span> ELM_NO <\/span>IN<\/span> DSTATS-REC<\/span><\/span>\n        <\/span>LOCK<\/span> <\/span>MODE<\/span> <\/span>IS<\/span> <\/span>AUTOMATIC<\/span><\/span>\n        <\/span>FILE<\/span> <\/span>STATUS<\/span> <\/span>IS<\/span> D-STAT.<\/span><\/span>\n<\/span>\nDATA DIVISION<\/span>.<\/span><\/span>\n<\/span>\nFILE SECTION<\/span>.<\/span><\/span>\n<\/span>\nFD<\/span>  DRAW-STATS<\/span><\/span>\n    <\/span>IS<\/span> <\/span>GLOBAL<\/span><\/span>\n    <\/span>LABEL<\/span> <\/span>RECORDS<\/span> <\/span>ARE STANDARD<\/span>.<\/span><\/span>\n<\/span>\n    <\/span>COPY<\/span> <\/span>'CDD_RECORDS.ZILLIONARE_STATS_RECORD'<\/span> <\/span>FROM<\/span> <\/span>DICTIONARY<\/span><\/span>\n        <\/span>REPLACING<\/span> ZILLIONARE_STATS_RECORD <\/span>BY<\/span> DSTATS-REC.<\/span><\/span>\n<\/span>\nPROCEDURE<\/span> DIVION.<\/span><\/span>\n<\/span>\n*<\/span><\/span>\n*       Create new output files<\/span><\/span>\n*<\/span><\/span>\n    <\/span>CALL<\/span> <\/span>'LIB$SPAWN'<\/span> <\/span>USING<\/span> <\/span>BY<\/span> DESCRIPTOR<\/span><\/span>\n        <\/span>'CREATE\/FDL=MEGA_DAT:MEGA_STATS.FDL DRAWING_STATS'<\/span>.<\/span><\/span>\n<\/span>\n    <\/span>OPEN<\/span> <\/span>I-O<\/span> DRAW-STATS.<\/span><\/span>\n...<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
FORTRAN 77<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
     ! FORTRAN <\/span>77<\/span><\/span>\n<\/span>\n        INCLUDE <\/span>'<\/span>MEGA_TEXT_LIB (FTN_MEGA_RECS)<\/span>'<\/span><\/span>\n<\/span>\n...<\/span><\/span>\n <\/span>220<\/span>    <\/span>OPEN<\/span> (<\/span>UNIT=<\/span>K_DSTAT_CHAN, <\/span><\/span>\n     <\/span>1<\/span>        <\/span>FILE=<\/span>DRAWING_STATS,<\/span><\/span>\n     <\/span>2<\/span>        <\/span>STATUS=<\/span>'<\/span>NEW<\/span>'<\/span>,<\/span><\/span>\n     <\/span>3<\/span>        ORGANIZATION<\/span>=<\/span>'<\/span>INDEXED<\/span>'<\/span>,<\/span><\/span>\n     <\/span>4<\/span>        ACCESS<\/span>=<\/span>'<\/span>KEYED<\/span>'<\/span>,<\/span><\/span>\n     <\/span>5<\/span>        RECORDTYPE<\/span>=<\/span>'<\/span>FIXED<\/span>'<\/span>,<\/span><\/span>\n     <\/span>6<\/span>        FORM<\/span>=<\/span>'<\/span>UNFORMATTED<\/span>'<\/span>,<\/span><\/span>\n     <\/span>7<\/span>        RECL<\/span>=<\/span>K_ZILLIONARE_STATS_RECORD_SIZE<\/span>\/<\/span>4<\/span>,<\/span><\/span>\n     <\/span>8<\/span>        CARRIAGECONTROL<\/span>=<\/span>'<\/span>FORTRAN<\/span>'<\/span>,<\/span><\/span>\n     <\/span>9<\/span>        <\/span>KEY=<\/span>(1:4:<\/span>INTEGER<\/span>),<\/span><\/span>\n     <\/span>1<\/span>        DISP<\/span>=<\/span>'<\/span>KEEP<\/span>'<\/span>,<\/span><\/span>\n     <\/span>2<\/span>        IOSTAT<\/span>=<\/span>L_D_STAT,<\/span><\/span>\n     <\/span>3<\/span>        SHARED,<\/span><\/span>\n     <\/span>4<\/span>        ERR<\/span>=<\/span>996<\/span>)<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
Our Key Was Part of the Data<\/h2>\n\n\n\n
Unlike std::map, std::set and the other sorted containers, our key was not separate from the data. Our key could be the entire record and the record could consist of just a single field. We had random access, and sequential access. If you had multiple keys for a record, once you performed a keyed hit to establish a key of reference, every sequential read after that read in that key’s order.<\/p>\n\n\n\n
Take a look at continuation 9 in the FORTRAN IV snippet. It identifies bytes one through four as a key of integer type. Guess it doesn’t mean much to you without the record layout.<\/p>\n\n\n\n
Drawing_Stats \nElm_no          integer k0 \nHit_count       integer \nLast_draw_no    integer\nSince_last      integer\nCurr_seq        integer\nLongest_seq     integer\nPct_hits        double\nMax_btwn        integer\nAve_btwn        double<\/pre>\n\n\n\n
In the world of professional software development we number our keys. K0 is always the primary key.<\/p>\n\n\n\n
Yes We Could Sort<\/h2>\n\n\n\n
If need be we could write things to a sequential file then use the system sort utility to create a new sorted file and read that as input. Usually we did this in a designated “scratch” area so the system managers could quickly reclaim the space if we happened to forget.<\/p>\n\n\n\n
A large part of this discussion is pointing out the fact we would never sort more than a tiny handful of items that physically could not number in the triple digits.<\/p>\n\n\n\n
Consider Resource Limitations<\/h2>\n\n\n\n
It was true in the 1970s and it is still true today; You will always have more physical storage than physical RAM. Not all storage may be online at all times, (i.e. tape library machines) but that number will always be bigger.<\/p>\n\n\n
\n
\"\"\/
Automated tape library system<\/figcaption><\/figure>\n<\/div>\n\n\n
If you think these things are going away any time soon, think again. IBM can store 330TB uncompressed on a palm sized tape cartridge<\/a>. Take a moment and count just how many tape cartridge slots you can see in this dark robot library picture.<\/p>\n\n\n\n
If You Ever!<\/h2>\n\n\n\n
If you ever create something like QSqlTableModel<\/a> or QTableView<\/a> where the model has to physically load all of the cursor results into RAM instead of using the cursor contents directly, when I die I will come back and haunt your children in a manner that makes Freddy Krueger seem like Jimminy Cricket. <\/p>\n\n\n
\n
\"\"\/
Freddy Krueger from Nightmare on Elm Street<\/figcaption><\/figure>\n<\/div>\n\n
\n
\"\"\/
Jiminy Cricket<\/figcaption><\/figure>\n<\/div>\n\n\n
I will haunt their offspring and every generation thereafter until your heirs decide it is best not to procreate and thus your DNA is eliminated from the gene pool.<\/p>\n\n\n\n
Today’s databases can return massive amounts of data from a single table<\/a>.<\/p>\n\n\n
\n
\"\"<\/figure>\n<\/div>\n\n\n
When you issue<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
SELECT<\/span> <\/span>*<\/span> <\/span>FROM<\/span> MY_TABLE;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
It is theoretically possible the resulting cursor could contain 32TB if the default was taken at database creation time. It could also return 128TB. I am ranting about this because I have seen people select from a database and load it into a list or other in-memory container without ever once checking the size of the data. Yes, I saw it because a program that had “run for years” was crashing nobody knew why.<\/p>\n\n\n\n
Sadly QSqlTableModel is in production in a lot of places using PostgreSQL databases like a ticking time bomb where one day the application will just crash because the table in the database got too big to load. Don’t you<\/strong><\/em> create ticking time bombs!<\/p>\n\n\n\n
A crash is actually the best possible outcome. Worse yet would be to just ignore what didn’t fit without crashing or throwing any kind of exception to be caught and handled. The user will continue on for years not having all of the data, eventually not having even correct data, because someone’s code quietly failed.<\/p>\n\n\n\n
Never Jump Right In With the New Stuff<\/h2>\n\n\n\n
I need to issue you yet another cautionary tale like I did with trigraphs<\/a>.<\/p>\n\n\n
\n
\"\"<\/figure>\n<\/div>\n\n\n
The day your shop changes to C++20 as it’s compilation standard you lose a bunch of operators for std::list.<\/p>\n\n\n\n
Academics Hose Things<\/h2>\n\n\n\n
C++ is a language at an age where new academics are replacing the dying old academics. Judging from many of the decisions being made neither worked a day in their life writing and supporting production code. They certainly never spent even one day in a COBOL class.<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
    <\/span>01<\/span> STATUS-VARIABLES.<\/span><\/span>\n       <\/span>05<\/span> IN-STAT           <\/span>PIC X<\/span>(<\/span>2<\/span>).<\/span><\/span>\n       <\/span>05<\/span> DRAW-STAT         <\/span>PIC X<\/span>(<\/span>2<\/span>).<\/span><\/span>\n       <\/span>05<\/span> ARE-THERE-MORE-RECORDS    <\/span>PIC X<\/span> <\/span>VALUE<\/span> <\/span>'<\/span>Y<\/span>'<\/span>.<\/span><\/span>\n          <\/span>88<\/span> THERE-ARE-MORE-RECORDS       <\/span>VALUE<\/span> <\/span>'<\/span>Y<\/span>'<\/span>.<\/span><\/span>\n          <\/span>88<\/span> THERE-ARE-NO-MORE-RECORDS    <\/span>VALUE<\/span> <\/span>'<\/span>N<\/span>'<\/span>.<\/span><\/span>\n       <\/span>05<\/span> IS-OPEN-FLAG      <\/span>PIC X.<\/span><\/span>\n          <\/span>88<\/span> FILE-IS-OPEN   <\/span>VALUE<\/span> <\/span>'<\/span>Y<\/span>'<\/span>.<\/span><\/span>\n<\/span>\n...<\/span><\/span>\n<\/span>\n    <\/span>PERFORM<\/span> B010-LOAD-DATA<\/span><\/span>\n        <\/span>UNTIL<\/span> THERE-ARE-NO-MORE-RECORDS.<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
Things that are yes\/no boolean type entities start with either “are” or “is” depending on what will be more grammatically correct. 88 levels are where we assigned names to values a field could have. You only had to assign names for interesting values.<\/p>\n\n\n\n
This rant is because everyone of these containers has an empty() method that should be isEmpty() [or is_empty() if we finally purge Pascal from C++]. If it had that name none of you would code it assuming it emptied the container. No, to empty a container you must use clear()<\/strong> because empty() only tells you if the container is empty. Isn’t that obvious?<\/p>\n\n\n\n
The Code<\/h2>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/\/ global includes before local<\/span><\/span>\n#include<\/span> <\/span><<\/span>iostream<\/span>><\/span><\/span>\n#include<\/span> <\/span><<\/span>list<\/span>><\/span><\/span>\n#include<\/span> <\/span><<\/span>algorithm<\/span>><\/span><\/span>\n#include<\/span> <\/span><<\/span>random<\/span>><\/span><\/span>\n#include<\/span> <\/span><<\/span>functional<\/span>><\/span><\/span>\n<\/span>\n#include<\/span> <\/span>"<\/span>config.h<\/span>"<\/span><\/span>\n<\/span>\nvoid<\/span> <\/span>dumpList<\/span>(<\/span>std<\/span>::<\/span>list<\/span><<\/span>double<\/span>><\/span> <\/span>&<\/span>dblList<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> <\/span>(!<\/span>dblList<\/span>.<\/span>empty<\/span>())<\/span>  \/\/ this is the proper use of empty()<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span> { <\/span>"<\/span>;<\/span><\/span>\n\t\t<\/span>for<\/span> <\/span>(<\/span>double<\/span> dbl <\/span>:<\/span> dblList<\/span>)<\/span><\/span>\n\t\t<\/span>{<\/span><\/span>\n\t\t\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> dbl <\/span><<<\/span> <\/span>"<\/span>, <\/span>"<\/span>;<\/span><\/span>\n\t\t<\/span>}<\/span><\/span>\n\t\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>}; <\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n\t<\/span>else<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span> The list is empty<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nbool<\/span> <\/span>tooBig<\/span>(<\/span> <\/span>std<\/span>::<\/span>list<\/span><<\/span>double<\/span>><\/span> <\/span>&<\/span>dblList<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>bool<\/span> retVal <\/span>=<\/span> <\/span>false;<\/span><\/span>\n<\/span>\n\t<\/span>if<\/span> <\/span>((<\/span>dblList<\/span>.<\/span>size<\/span>()<\/span> <\/span>+<\/span> <\/span>1000<\/span>)<\/span> <\/span>><\/span> dblList<\/span>.<\/span>max_size<\/span>())<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\tretVal <\/span>=<\/span> <\/span>true;<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n<\/span>\n\t<\/span>return<\/span> retVal<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nbool<\/span> <\/span>getUserInput<\/span>(<\/span>std<\/span>::<\/span>list<\/span><<\/span>double<\/span>><\/span> <\/span>&<\/span>dblList<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>if<\/span> <\/span>(<\/span>tooBig<\/span>(<\/span> dblList<\/span>))<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>return<\/span> <\/span>false;<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n<\/span>\n\t<\/span>bool<\/span> retVal <\/span>=<\/span> <\/span>true;<\/span><\/span>\n\t<\/span>double<\/span> dbl <\/span>{};<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>Enter a floating point value or 999 to quit: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cin <\/span>>><\/span> dbl<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>if<\/span> <\/span>(<\/span>dbl <\/span>==<\/span> <\/span>999<\/span>)<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\tretVal <\/span>=<\/span> <\/span>false;<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n\t<\/span>else<\/span> <\/span>if<\/span> <\/span>((<\/span>dblList<\/span>.<\/span>size<\/span>()<\/span> <\/span>%<\/span> <\/span>2<\/span>)<\/span> <\/span>==<\/span> <\/span>0<\/span>)<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>dblList<\/span>.<\/span>push_front<\/span>(<\/span> dbl<\/span>);<\/span>\t\/\/ add to front of list<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n\t<\/span>else<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>dblList<\/span>.<\/span>push_back<\/span>(<\/span> dbl<\/span>);<\/span>\t\/\/ add to back\/end of list<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n<\/span>\n\t<\/span>return<\/span> retVal<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>,<\/span> <\/span>char<\/span> <\/span>**<\/span>argv<\/span>)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>ListContainerExample<\/span>"<\/span> <\/span><<<\/span> <\/span>std<\/span>::<\/span>endl<\/span>;<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>Version <\/span>"<\/span> <\/span><<<\/span> ListContainerExample_VERSION_MAJOR <\/span><<<\/span> <\/span>"<\/span>.<\/span>"<\/span><\/span>\n\t\t\t<\/span><<<\/span> ListContainerExample_VERSION_MINOR <\/span><<<\/span> <\/span>std<\/span>::<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>::<\/span>list<\/span><<\/span>double<\/span>><\/span> myList <\/span>{<\/span> <\/span>3.14159<\/span>,<\/span> <\/span>0.32<\/span>,<\/span> <\/span>-<\/span>0.60<\/span>,<\/span> <\/span>-<\/span>505.123<\/span>,<\/span> <\/span>987.01<\/span> <\/span>};<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>list before user input: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList<\/span>);<\/span><\/span>\n<\/span>\n\t<\/span>while<\/span> <\/span>(<\/span>getUserInput<\/span>(<\/span>myList<\/span>));<\/span>  \t\/\/ this is not an infinite loop<\/span><\/span>\n\t\t\t\t\t\t\t\t\t\/\/ some might want to use a do while here<\/span><\/span>\n\t\t\t\t\t\t\t\t\t\/\/ but that creates needless temporaries<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>list after user input: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList<\/span>);<\/span><\/span>\n<\/span>\n\t\/\/ NEVER USE AUTO IN PRODUCTION CODE!<\/span><\/span>\n\t\/\/<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>list<\/span><<\/span>double<\/span>>::<\/span>iterator it <\/span>=<\/span> <\/span>find<\/span>(<\/span>myList<\/span>.<\/span>begin<\/span>(),<\/span> myList<\/span>.<\/span>end<\/span>(),<\/span> <\/span>-<\/span>505.123<\/span>);<\/span><\/span>\n\t<\/span>if<\/span> <\/span>(<\/span>it <\/span>!=<\/span> myList<\/span>.<\/span>end<\/span>())<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>myList<\/span>.<\/span>insert<\/span>(<\/span>it<\/span>,<\/span> <\/span>-<\/span>0.60<\/span>);<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>list after insert: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList<\/span>);<\/span><\/span>\n<\/span>\n\tmyList<\/span>.<\/span>sort<\/span>(<\/span> <\/span>std<\/span>::<\/span>less<\/span><<\/span>double<\/span>>());<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>list after descending sort: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList <\/span>);<\/span><\/span>\n<\/span>\n\tmyList<\/span>.<\/span>unique<\/span>();<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>list after removing duplicates: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList <\/span>);<\/span><\/span>\n<\/span>\n\tmyList<\/span>.<\/span>sort<\/span>();<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>list after ascending sort: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList <\/span>);<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>adding some more values<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>double<\/span> lowerBound <\/span>=<\/span> <\/span>0<\/span>;<\/span><\/span>\n\t<\/span>double<\/span> upperBound <\/span>=<\/span> <\/span>10000<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>::<\/span>uniform_real_distribution<\/span><<\/span>double<\/span>><\/span> <\/span>unif<\/span>(<\/span> lowerBound<\/span>,<\/span> upperBound<\/span>);<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>default_random_engine rndEngine<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>for<\/span> <\/span>(<\/span>int<\/span> jjj<\/span>=<\/span>0<\/span>;<\/span> jjj <\/span><<\/span> <\/span>20<\/span>;<\/span> jjj<\/span>++)<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>myList<\/span>.<\/span>push_back<\/span>(<\/span> <\/span>unif<\/span>(<\/span>rndEngine<\/span>)<\/span> <\/span>);<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>after adding numbers: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList <\/span>);<\/span><\/span>\n<\/span>\n\t\/\/ You really have to use a lambda here. One of the few times I support<\/span><\/span>\n\t\/\/ use of a lambda. Mostly they should be avoided, especially if they return<\/span><\/span>\n\t\/\/ values and could be executed across threads like a signal\/slot arrangement.<\/span><\/span>\n\t\/\/<\/span><\/span>\n\tmyList<\/span>.<\/span>remove_if<\/span>(<\/span> <\/span>[](<\/span>double<\/span> <\/span>d<\/span>)<\/span> <\/span>{<\/span> <\/span>return<\/span> d <\/span><<\/span> <\/span>0.0<\/span>;});<\/span><\/span>\n\tmyList<\/span>.<\/span>sort<\/span>();<\/span><\/span>\n\t<\/span>std<\/span>::<\/span>cout <\/span><<<\/span> <\/span>"<\/span>after removing negatives and sorting: <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>dumpList<\/span>(<\/span> myList<\/span>);<\/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
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
cmake_minimum_required<\/span>(VERSION 3.10)<\/span><\/span>\n<\/span>\n# Set some basic project attributes<\/span><\/span>\nproject<\/span> (ListContainerExample<\/span><\/span>\n\tVERSION 0.1<\/span><\/span>\n\tDESCRIPTION <\/span>"A std::list Project"<\/span>)<\/span><\/span>\n<\/span>\nset<\/span>(CMAKE_CXX_STANDARD_REQUIRED <\/span>ON<\/span>)<\/span><\/span>\nset<\/span>(CMAKE_CXX_STANDARD 17)<\/span><\/span>\n<\/span>\n# This project will output an executable file<\/span><\/span>\nadd_executable<\/span>(${PROJECT_NAME} ListContainerExample.cpp)<\/span><\/span>\n<\/span>\n# Create a simple configuration header<\/span><\/span>\nconfigure_file<\/span>(config.h.in config.h)<\/span><\/span>\n<\/span>\n# Include the configuration header in the build<\/span><\/span>\ntarget_include_directories<\/span>(${PROJECT_NAME} PUBLIC <\/span>"${PROJECT_BINARY_DIR}"<\/span>)<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
ListContainerExample\nVersion 0.1\nlist before user input:  { 3.14159, 0.32, -0.6, -505.123, 987.01, }; \nEnter a floating point value or 999 to quit: 21.1\nEnter a floating point value or 999 to quit: 18.3\nEnter a floating point value or 999 to quit: 0.00004\nEnter a floating point value or 999 to quit: 0.00001\nEnter a floating point value or 999 to quit: 1.0006\nEnter a floating point value or 999 to quit: 33\nEnter a floating point value or 999 to quit: 254\nEnter a floating point value or 999 to quit: 88.7\nEnter a floating point value or 999 to quit: 999\nlist after user input:  { 88.7, 33, 1e-05, 18.3, 3.14159, 0.32, -0.6, -505.123, 987.01, 21.1, 4e-05, 1.0006, 254, }; \nlist after insert:  { 88.7, 33, 1e-05, 18.3, 3.14159, 0.32, -0.6, -0.6, -505.123, 987.01, 21.1, 4e-05, 1.0006, 254, }; \nlist after descending sort:  { -505.123, -0.6, -0.6, 1e-05, 4e-05, 0.32, 1.0006, 3.14159, 18.3, 21.1, 33, 88.7, 254, 987.01, }; \nlist after removing duplicates:  { -505.123, -0.6, 1e-05, 4e-05, 0.32, 1.0006, 3.14159, 18.3, 21.1, 33, 88.7, 254, 987.01, }; \nlist after ascending sort:  { -505.123, -0.6, 1e-05, 4e-05, 0.32, 1.0006, 3.14159, 18.3, 21.1, 33, 88.7, 254, 987.01, }; \nadding some more values\nafter adding numbers:  { -505.123, -0.6, 1e-05, 4e-05, 0.32, 1.0006, 3.14159, 18.3, 21.1, 33, 88.7, 254, 987.01, 1315.38, 4586.5, 2189.59, 6788.65, 9346.93, 5194.16, 345.721, 5297, 76.9819, 668.422, 6867.73, 9304.36, 5269.29, 6539.19, 7011.91, 7621.98, 474.645, 3282.34, 7564.1, 3653.39, }; \nafter removing negatives and sorting:  { 1e-05, 4e-05, 0.32, 1.0006, 3.14159, 18.3, 21.1, 33, 76.9819, 88.7, 254, 345.721, 474.645, 668.422, 987.01, 1315.38, 2189.59, 3282.34, 3653.39, 4586.5, 5194.16, 5269.29, 5297, 6539.19, 6788.65, 6867.73, 7011.91, 7564.1, 7621.98, 9304.36, 9346.93, }; \n<\/pre>\n\n\n\n
Summary<\/h2>\n\n\n\n
Don’t be upset if you didn’t know half of those STL creations, I had to look some up too. STL has gotten too big to utilize effectively and gotten so old parts of it are rotting away. When you are writing production<\/strong><\/em> code that needs to run correctly for years, possibly decades stay in the center lanes<\/em>. I have a system at a client site I wrote nearly 30 years ago, it still handles around $50 million in orders per day and despite massive changes to the business has not required modification in all that time. You IoT developers don’t manage to have functioning code in production a week.<\/p>\n\n\n\n
std::list does not have random access, you have to use find() to obtain an iterator.<\/p>\n\n\n\n
Never use auto in production code outside of a template!<\/strong><\/em><\/p>\n\n\n\n
Being fat and lazy does not produce quality code even if your TDD says otherwise. The rules aren’t hard core for auto. With non native data types you are one include file away from having a different class derived from the same base class chosen as the “auto” type. This produces wild unpredictable code paths in code that wasn’t changed<\/em>. Someone added the include to the include you are including and the happy path seemed to work.<\/p>\n\n\n\n
Notice the tooBig() function? Never ASS-U-ME you have enough room.<\/p>\n","protected":false},"excerpt":{"rendered":"
Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn’t until the IT industry was inundated with tiny x86 minds that people “tried to do it all in RAM.” Before the PC we had real computers with real operating systems. Other than Assembler, our languages were robust. Every platform supported indexed files and so did the compiler for every language. When we needed a multiply linked list … std::list – Example and Explanation<\/span>Read more<\/a><\/p>\n","protected":false},"author":2,"featured_media":6284,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[1],"tags":[438,1647,2169,1897,2167,2175],"class_list":["post-6303","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-uncategorized","tag-cobol","tag-dibol","tag-fortran-iv","tag-qsqltablemodel","tag-stdlist","tag-stdvector-c","bnm-entry"],"yoast_head":"\nstd::list - Example and Explanation – Logikal Blog<\/title>\n<meta name=\"description\" content=\"Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn't until the IT industry was . . .\" \/>\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\/uncategorized\/stdlist\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"std::list - Example and Explanation – Logikal Blog\" \/>\n<meta property=\"og:description\" content=\"Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn't until the IT industry was . . .\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/\" \/>\n<meta property=\"og:site_name\" content=\"Logikal Blog\" \/>\n<meta property=\"article:published_time\" content=\"2023-11-05T14:23:45+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-11-27T23:28:15+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg\" \/>\n\t<meta property=\"og:image:width\" content=\"1880\" \/>\n\t<meta property=\"og:image:height\" content=\"1253\" \/>\n\t<meta property=\"og:image:type\" content=\"image\/jpeg\" \/>\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\\\/uncategorized\\\/stdlist\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/\"},\"author\":{\"name\":\"seasoned_geek\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"headline\":\"std::list – Example and Explanation\",\"datePublished\":\"2023-11-05T14:23:45+00:00\",\"dateModified\":\"2023-11-27T23:28:15+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/\"},\"wordCount\":1124,\"commentCount\":0,\"publisher\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"image\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2023\\\/11\\\/pexels-photo-6991812.jpeg\",\"keywords\":[\"COBOL\",\"DIBOL\",\"FORTRAN IV\",\"QSqlTableModel\",\"std::list\",\"std::vector c++\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/\",\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/\",\"name\":\"std::list - Example and Explanation – Logikal Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2023\\\/11\\\/pexels-photo-6991812.jpeg\",\"datePublished\":\"2023-11-05T14:23:45+00:00\",\"dateModified\":\"2023-11-27T23:28:15+00:00\",\"description\":\"Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn't until the IT industry was . . .\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#primaryimage\",\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2023\\\/11\\\/pexels-photo-6991812.jpeg\",\"contentUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2023\\\/11\\\/pexels-photo-6991812.jpeg\",\"width\":1880,\"height\":1253,\"caption\":\"Photo by DS stories on Pexels.com\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/uncategorized\\\/stdlist\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"std::list – Example and Explanation\"}]},{\"@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":"std::list - Example and Explanation – Logikal Blog","description":"Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn't until the IT industry was . . .","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\/uncategorized\/stdlist\/","og_locale":"en_US","og_type":"article","og_title":"std::list - Example and Explanation – Logikal Blog","og_description":"Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn't until the IT industry was . . .","og_url":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/","og_site_name":"Logikal Blog","article_published_time":"2023-11-05T14:23:45+00:00","article_modified_time":"2023-11-27T23:28:15+00:00","og_image":[{"width":1880,"height":1253,"url":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","type":"image\/jpeg"}],"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\/uncategorized\/stdlist\/#article","isPartOf":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/"},"author":{"name":"seasoned_geek","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"headline":"std::list – Example and Explanation","datePublished":"2023-11-05T14:23:45+00:00","dateModified":"2023-11-27T23:28:15+00:00","mainEntityOfPage":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/"},"wordCount":1124,"commentCount":0,"publisher":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"image":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#primaryimage"},"thumbnailUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","keywords":["COBOL","DIBOL","FORTRAN IV","QSqlTableModel","std::list","std::vector c++"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/","url":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/","name":"std::list - Example and Explanation – Logikal Blog","isPartOf":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#primaryimage"},"image":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#primaryimage"},"thumbnailUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","datePublished":"2023-11-05T14:23:45+00:00","dateModified":"2023-11-27T23:28:15+00:00","description":"Our discussion of std::list, like our discussion of std::vector will start with a bit of history. It wasn't until the IT industry was . . .","breadcrumb":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#primaryimage","url":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","contentUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","width":1880,"height":1253,"caption":"Photo by DS stories on Pexels.com"},{"@type":"BreadcrumbList","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/uncategorized\/stdlist\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.logikalsolutions.com\/wordpress\/"},{"@type":"ListItem","position":2,"name":"std::list – Example and Explanation"}]},{"@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\/6303","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=6303"}],"version-history":[{"count":0,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/posts\/6303\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/media\/6284"}],"wp:attachment":[{"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/media?parent=6303"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/categories?post=6303"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/tags?post=6303"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}