{"id":6646,"date":"2023-11-27T14:06:17","date_gmt":"2023-11-27T20:06:17","guid":{"rendered":"https:\/\/www.logikalsolutions.com\/wordpress\/?p=6646"},"modified":"2023-11-27T17:24:42","modified_gmt":"2023-11-27T23:24:42","slug":"arrays-and-pointers","status":"publish","type":"post","link":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/","title":{"rendered":"C++ Arrays and Pointers Example"},"content":{"rendered":"\n

C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then declaring arrays of structures was a bit iffy. Much of that had to do with the Stack vs. Near Heap vs. Far Heap issues of memory segmentation and “bytes allocated for alignment.” Refer to the std::vector post<\/a> for further information on that.<\/p>\n\n\n\n

The Code<\/h2>\n\n\n\n

We have a lot to talk about with this short example. We are going to dynamically allocate an array, fill it with prime numbers, then print it out. Our main() will do almost nothing.<\/p>\n\n\n\n

<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/*  ArraysAndPointersExample<\/span><\/span>\n *<\/span><\/span>\n *  Never use auto in production code!!!<\/span><\/span>\n *\/<\/span><\/span>\n<\/span>\n\/\/ globals before locals<\/span><\/span>\n\/\/<\/span><\/span>\n#include <\/span><<\/span>iostream<\/span>><\/span><\/span>\n#include <\/span><<\/span>iomanip<\/span>><\/span><\/span>\n#include <\/span><<\/span>cmath<\/span>><\/span><\/span>\n#include <\/span><<\/span>cstdlib<\/span>><\/span><\/span>\n<\/span>\n#include <\/span>"<\/span>config.h<\/span>"<\/span><\/span>\n<\/span>\nunsigned long <\/span>*<\/span> <\/span>allocateAndFill<\/span>( size_t max)<\/span>;<\/span><\/span>\nvoid<\/span> <\/span>reportPrimes<\/span>( size_t max<\/span>,<\/span> unsigned long <\/span>*<\/span>primes)<\/span>;<\/span><\/span>\n<\/span>\nint <\/span>main<\/span>(int argc<\/span>,<\/span> char <\/span>**<\/span>argv) <\/span>{<\/span><\/span>\n\t<\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>"<\/span>ArraysAndPointersExample<\/span>"<\/span> <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>endl<\/span>;<\/span><\/span>\n\t<\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>"<\/span>Version <\/span>"<\/span> <\/span><<<\/span> <\/span>ArraysAndPointersExample_VERSION_MAJOR<\/span> <\/span><<<\/span> <\/span>"<\/span>.<\/span>"<\/span> <\/span><<<\/span> <\/span>ArraysAndPointersExample_VERSION_MINOR<\/span> <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>size_t<\/span> <\/span>max<\/span> <\/span>{};<\/span><\/span>\n<\/span>\n\t<\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>"<\/span>How many primes would you like to find? <\/span>"<\/span>;<\/span><\/span>\n\t<\/span>std<\/span>:<\/span>:<\/span>cin<\/span> <\/span>>><\/span> <\/span>max<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>if<\/span> (<\/span>max<\/span> <\/span>><\/span> <\/span>0<\/span>)<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>unsigned<\/span> <\/span>long<\/span> <\/span>*<\/span>primes<\/span> <\/span>=<\/span> <\/span>allocateAndFill<\/span>( <\/span>max<\/span>)<\/span>;<\/span><\/span>\n<\/span>\n\t\t<\/span>reportPrimes<\/span>( <\/span>max<\/span>,<\/span> <\/span>primes<\/span>)<\/span>;<\/span><\/span>\n<\/span>\n\t\t<\/span>delete<\/span>[] <\/span>primes<\/span>;<\/span>\t\t<\/span>\/\/ don't forget to clean up<\/span><\/span>\n\t\t\t\t\t\t\t\t<\/span>\/\/ thanks to standard changes this works even<\/span><\/span>\n\t\t\t\t\t\t\t\t<\/span>\/\/ if primes is a nullptr.<\/span><\/span>\n<\/span>\n\t\t<\/span>primes<\/span> <\/span>=<\/span> <\/span>nullptr<\/span>;<\/span>\t\t<\/span>\/\/ just to be polite<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n<\/span>\n\t<\/span>\/*<\/span><\/span>\n\t * Tiny x86 minds have a bad habit of hard coding 0. I've done it myself.<\/span><\/span>\n\t * This is an extremely bad practice which shreds portability.  OpenVMS<\/span><\/span>\n\t * interprets the low-order bits of $STATUS (found in $SEVERITY) like so:<\/span><\/span>\n\t *<\/span><\/span>\n\t * 0 = Warning ("%facility-W-mnemonic, message text")<\/span><\/span>\n\t * 1 = Success (No message by default)<\/span><\/span>\n\t * 2 = Error ("%facility-E-mnemonic, message text")<\/span><\/span>\n\t * 3 = Informational ("%facility-I-mnemonic, message text")<\/span><\/span>\n\t * 4 = Severe (Fatal) Error ("%facility-F-mnemonic, message text")<\/span><\/span>\n\t *<\/span><\/span>\n\t * Read this book<\/span><\/span>\n\t * https:\/\/www.theminimumyouneedtoknow.com\/app_book.html<\/span><\/span>\n\t * for more information on that.<\/span><\/span>\n\t *<\/span><\/span>\n\t * Many other real computer platforms encode the bits in other ways so a<\/span><\/span>\n\t * return value may have a wide range of "success" values that can codify<\/span><\/span>\n\t * the level of success.<\/span><\/span>\n\t *<\/span><\/span>\n\t * On OpenVMS EXIT_SUCCESS typically gets mapped to SS$_NORMAL.<\/span><\/span>\n\t *<\/span><\/span>\n\t * Note the (). Many people don't use them (myself included) but<\/span><\/span>\n\t * return is a function.<\/span><\/span>\n\t *\/<\/span><\/span>\n\t<\/span>return<\/span> (<\/span>EXIT_SUCCESS<\/span>)<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nunsigned long <\/span>*<\/span> <\/span>allocateAndFill<\/span>( size_t max)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>\/*<\/span><\/span>\n\t * Unlike a declared array this will not go away when we<\/span><\/span>\n\t * exit the function. Anything you "new" you must delete yourself.<\/span><\/span>\n\t * Note that we allocate this array in a called function and delete<\/span><\/span>\n\t * it in the main.<\/span><\/span>\n\t *\/<\/span><\/span>\n\t<\/span>unsigned<\/span> <\/span>long<\/span> <\/span>*<\/span>primes<\/span> <\/span>{new<\/span> <\/span>unsigned<\/span> <\/span>long<\/span>[<\/span>max<\/span>]<\/span>};<\/span><\/span>\n<\/span>\n\t<\/span>size_t<\/span> <\/span>count<\/span> <\/span>{<\/span>1<\/span>};<\/span>\t\t<\/span>\/\/ count of primes found<\/span><\/span>\n\t<\/span>primes<\/span>[<\/span>0<\/span>] <\/span>=<\/span> <\/span>2<\/span>;<\/span>\t\t\t<\/span>\/\/ first prime<\/span><\/span>\n<\/span>\n\t<\/span>unsigned<\/span> <\/span>long<\/span> <\/span>trial<\/span> <\/span>{<\/span>primes<\/span>[<\/span>0<\/span>]<\/span>+<\/span>1<\/span>};<\/span><\/span>\n<\/span>\n\t<\/span>while<\/span> (<\/span>count<\/span> <\/span><<\/span> <\/span>max<\/span> )<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>bool<\/span> <\/span>isPrime<\/span> <\/span>{<\/span>true<\/span>};<\/span><\/span>\n<\/span>\n\t\t<\/span>\/*<\/span><\/span>\n\t\t * bit of a cheat here. Stops us from running through entire list.<\/span><\/span>\n\t\t * mathematically, if the value we are dividing by with modulus<\/span><\/span>\n\t\t * gets up to the integer of the square root we can stop. Nothing larger<\/span><\/span>\n\t\t * could be an even division.<\/span><\/span>\n\t\t *\/<\/span><\/span>\n\t\t<\/span>const<\/span> <\/span>unsigned<\/span> long limit <\/span>=<\/span> <\/span>static_cast<\/span><<\/span>unsigned<\/span> <\/span>long<\/span>>(<\/span>std<\/span>::<\/span>sqrt<\/span>(<\/span>trial<\/span>)<\/span>)<\/span>;<\/span><\/span>\n\t\tfor <\/span>(<\/span>size_t<\/span> <\/span>i<\/span> <\/span>{}<\/span>; <\/span>primes<\/span>[<\/span>i<\/span>]<\/span> <<\/span>=<\/span> <\/span>limit<\/span> <\/span>&&<\/span> <\/span>isPrime<\/span>; ++<\/span>i<\/span>)<\/span><\/span>\n\t\t<\/span>{<\/span><\/span>\n\t\t\t<\/span>isPrime<\/span> <\/span>=<\/span> <\/span>trial<\/span> <\/span>%<\/span> <\/span>primes<\/span>[<\/span>i<\/span>] <\/span>><\/span> <\/span>0<\/span>;\t<\/span>\/\/ False for exact division<\/span><\/span>\n\t\t<\/span>}<\/span><\/span>\n<\/span>\n\t\t<\/span>if<\/span> (<\/span>isPrime<\/span>)<\/span><\/span>\n\t\t<\/span>{<\/span><\/span>\n\t\t\t<\/span>primes<\/span>[<\/span>count<\/span>++<\/span>] <\/span>=<\/span> <\/span>trial<\/span>;<\/span><\/span>\n\t\t<\/span>}<\/span><\/span>\n<\/span>\n\t\t<\/span>trial<\/span> <\/span>+=<\/span> <\/span>2<\/span>;<\/span>\t\t<\/span>\/\/ this is a cheat. It works because we pre-load 2<\/span><\/span>\n\t\t\t\t\t\t<\/span>\/\/ and our first trial is 3. If you set the trial to<\/span><\/span>\n\t\t\t\t\t\t<\/span>\/\/ the first prime value in the list (2) this code<\/span><\/span>\n\t\t\t\t\t\t<\/span>\/\/ would never find another.<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n<\/span>\n\t<\/span>return<\/span> (<\/span>primes<\/span>)<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n\/\/\toutput 10 to a line<\/span><\/span>\nvoid<\/span> <\/span>reportPrimes<\/span>( size_t max<\/span>,<\/span> unsigned long <\/span>*<\/span>primes)<\/span><\/span>\n{<\/span><\/span>\n\t<\/span>const<\/span> <\/span>size_t<\/span> PER_LINE <\/span>=<\/span> <\/span>10<\/span>;<\/span><\/span>\n\t<\/span>const<\/span> <\/span>size_t<\/span> PRINT_WIDTH <\/span>=<\/span> <\/span>10<\/span>;<\/span><\/span>\n<\/span>\n\t<\/span>for<\/span> (<\/span>size_t<\/span> <\/span>i<\/span> <\/span>{};<\/span> <\/span>i<\/span> <\/span><<\/span> <\/span>max<\/span>;<\/span> <\/span>++<\/span>i<\/span>)<\/span><\/span>\n\t<\/span>{<\/span><\/span>\n\t\t<\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>setw<\/span>(<\/span>PRINT_WIDTH<\/span>) <\/span><<<\/span> <\/span>primes<\/span>[<\/span>i<\/span>]<\/span>;<\/span><\/span>\n\t\t<\/span>if<\/span> ((<\/span>i<\/span>+<\/span>1<\/span>) <\/span>%<\/span> <\/span>PER_LINE<\/span> <\/span>==<\/span> <\/span>0<\/span>)<\/span><\/span>\n\t\t<\/span>{<\/span><\/span>\n\t\t\t<\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>endl<\/span>;<\/span><\/span>\n\t\t<\/span>}<\/span><\/span>\n\t<\/span>}<\/span><\/span>\n\t<\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>endl<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span><\/code><\/pre><\/div>\n\n\n\n
The Array<\/h3>\n\n\n\n
Lines 27 through 38 are the first thing we need to talk about. When you carve your main() down to the basics, you can avoid multiple exits wrapping the meat of the application within an if statement. Most examples stuff everything into main() but that is not a good way of doing things. Unless an application framework forces you to do otherwise main() should have no more than twenty lines of actual code. A hundred lines of comments are fine, but actual code should be under twenty. <\/p>\n\n\n\n
If it isn’t obvious, via the comment when reading lines 29 and 33, we allocate our array via a called function. Dropping down to line 75 you will see where we new it inside of an initializer so it is zeroed. Any time you new something, it lives until you nuke it via an appropriate delete. A stack declared<\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
unsigned long primes [max]<\/span>;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
is not initalized and ceases to exist when it goes out of scope. Since we are talking about arrays and pointers with this example, stack declared arrays are also a pointer.<\/p>\n\n\n\n
Old School Array Use<\/h4>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
\/*  p-test-1<\/span><\/span>\n *<\/span><\/span>\n *<\/span><\/span>\n *\/<\/span><\/span>\n<\/span>\n\/\/ globals before locals<\/span><\/span>\n\/\/<\/span><\/span>\n#include <\/span><<\/span>iostream<\/span>><\/span><\/span>\n#include <\/span><<\/span>iomanip<\/span>><\/span><\/span>\n#include <\/span><<\/span>cmath<\/span>><\/span><\/span>\n#include <\/span><<\/span>cstdlib<\/span>><\/span><\/span>\n<\/span>\nint <\/span>main<\/span>( int argc<\/span>,<\/span> char <\/span>**<\/span>argv )<\/span><\/span>\n{<\/span><\/span>\n    <\/span>unsigned<\/span> <\/span>long<\/span> <\/span>tbl<\/span> [] <\/span>{<\/span>24<\/span>,<\/span> <\/span>56<\/span>,<\/span> <\/span>1<\/span>,<\/span> <\/span>99<\/span>,<\/span> <\/span>256<\/span>};<\/span><\/span>\n    <\/span>unsigned<\/span> <\/span>long<\/span> <\/span>*<\/span>ptr<\/span> <\/span>=<\/span> <\/span>tbl<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>"<\/span>tbl [3]: <\/span>"<\/span> <\/span><<<\/span> <\/span>tbl<\/span>[<\/span>3<\/span>] <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>ptr<\/span> <\/span>+=<\/span>4<\/span>;<\/span><\/span>\n    <\/span>std<\/span>:<\/span>:<\/span>cout<\/span> <\/span><<<\/span> <\/span>"<\/span>value at ptr + 4: <\/span>"<\/span> <\/span><<<\/span> <\/span>*<\/span>ptr<\/span> <\/span><<<\/span> <\/span>std<\/span>:<\/span>:<\/span>endl<\/span>;<\/span><\/span>\n<\/span>\n    <\/span>return<\/span> ( <\/span>EXIT_SUCCESS<\/span> )<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
roland@roland-HP-Z2-SFF-G4-Workstation:~\/Projects\/p-test-1$ g++ main.cpp -o p-test-1
roland@roland-HP-Z2-SFF-G4-Workstation:~\/Projects\/p-test-1$ ls
main.cpp  p-test-1
roland@roland-HP-Z2-SFF-G4-Workstation:~\/Projects\/p-test-1$ .\/p-test-1 
tbl [3]: 99
value at ptr + 4: 256
<\/pre>\n\n\n\n
Things most definitely got out of hand and developers took this to extremes. Read the 3-Dimensional array example code in this post<\/a>. There is absolutely no reason to write code like that in production today! The fact someone thinks it is a legit coding test is exactly<\/em> why senior developers walk out of interviews. We won’t do shit like that! Only a skill-less hack would.<\/p>\n\n\n\n
In the 1980s before we had Vector classes and in-memory SQLite database tables, we had to do things like that. Deep in the bowels of every relational database engine there is probably code like that. It should not exist in production code you write!<\/strong> Someone fresh out of school will have to maintain that.<\/p>\n\n\n\n
return is a function<\/h2>\n\n\n\n
Please read the rant in the comments found in lines 40 – 63. I’m as guilty as sin when it comes to leaving the () off a single return value. I have had clients pointing it out since the late 1980s. One of the few things I like about Eclipse is that it flags the mission () as a bug.<\/p>\n\n\n\n
Having spent the past decade on x86 wanna-be-a-real-computer-one-day-when-I-grow-up processors, I’ve also got many bad examples out there of <\/p>\n\n\n\n
<\/circle><\/circle><\/circle><\/g><\/svg><\/span><\/path><\/path><\/svg><\/span>
return<\/span> (<\/span>0<\/span>)<\/span>;<\/span><\/span><\/code><\/pre><\/div>\n\n\n\n
When you do that, the code is non-portable. Only on x86 and some ARM processors that cloned x86 bad habits is zero considered a success. In the land of real computers every OS has some form of $SEVERITY where a set of bits in the return value are a category mask. In the land of OpenVMS odd values are success, even failure and zero a warning. The rest of that integer return contains a “message number” you can use to lookup what, if any, issue occurred. <\/p>\n\n\n\n
The Output<\/h2>\n\n\n\n
ArraysAndPointersExample
Version 0.1
How many primes would you like to find? 200
         2         3         5         7        11        13        17        19        23        29
        31        37        41        43        47        53        59        61        67        71
        73        79        83        89        97       101       103       107       109       113
       127       131       137       139       149       151       157       163       167       173
       179       181       191       193       197       199       211       223       227       229
       233       239       241       251       257       263       269       271       277       281
       283       293       307       311       313       317       331       337       347       349
       353       359       367       373       379       383       389       397       401       409
       419       421       431       433       439       443       449       457       461       463
       467       479       487       491       499       503       509       521       523       541
       547       557       563       569       571       577       587       593       599       601
       607       613       617       619       631       641       643       647       653       659
       661       673       677       683       691       701       709       719       727       733
       739       743       751       757       761       769       773       787       797       809
       811       821       823       827       829       839       853       857       859       863
       877       881       883       887       907       911       919       929       937       941
       947       953       967       971       977       983       991       997      1009      1013
      1019      1021      1031      1033      1039      1049      1051      1061      1063      1069
      1087      1091      1093      1097      1103      1109      1117      1123      1129      1151
      1153      1163      1171      1181      1187      1193      1201      1213      1217      1223<\/pre>\n","protected":false},"excerpt":{"rendered":"
C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then declaring arrays of structures was a bit iffy. Much of that had to do with the Stack vs. Near Heap vs. Far Heap issues of memory segmentation and “bytes allocated for alignment.” Refer to the std::vector post for further information on that. The Code We have a lot to talk about with this short … C++ Arrays and Pointers Example<\/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":[3],"tags":[2176,1504,1189],"class_list":["post-6646","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-information-technology","tag-arrays","tag-c","tag-pointers","bnm-entry"],"yoast_head":"\nC++ Arrays and Pointers Example – Logikal Blog<\/title>\n<meta name=\"description\" content=\"C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then . .\" \/>\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\/arrays-and-pointers\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"C++ Arrays and Pointers Example – Logikal Blog\" \/>\n<meta property=\"og:description\" content=\"C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then . .\" \/>\n<meta property=\"og:url\" content=\"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/\" \/>\n<meta property=\"og:site_name\" content=\"Logikal Blog\" \/>\n<meta property=\"article:published_time\" content=\"2023-11-27T20:06:17+00:00\" \/>\n<meta property=\"article:modified_time\" content=\"2023-11-27T23:24:42+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=\"5 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\\\/arrays-and-pointers\\\/#article\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/\"},\"author\":{\"name\":\"seasoned_geek\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"headline\":\"C++ Arrays and Pointers Example\",\"datePublished\":\"2023-11-27T20:06:17+00:00\",\"dateModified\":\"2023-11-27T23:24:42+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/\"},\"wordCount\":572,\"commentCount\":1,\"publisher\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#\\\/schema\\\/person\\\/c077f770ade13de7faaf616c3eac6842\"},\"image\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2023\\\/11\\\/pexels-photo-6991812.jpeg\",\"keywords\":[\"arrays\",\"C++\",\"pointers\"],\"articleSection\":[\"Information Technology\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/\",\"url\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/\",\"name\":\"C++ Arrays and Pointers Example – Logikal Blog\",\"isPartOf\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/#primaryimage\"},\"image\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/#primaryimage\"},\"thumbnailUrl\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/wp-content\\\/uploads\\\/2023\\\/11\\\/pexels-photo-6991812.jpeg\",\"datePublished\":\"2023-11-27T20:06:17+00:00\",\"dateModified\":\"2023-11-27T23:24:42+00:00\",\"description\":\"C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then . .\",\"breadcrumb\":{\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/information-technology\\\/arrays-and-pointers\\\/#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\\\/information-technology\\\/arrays-and-pointers\\\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"https:\\\/\\\/www.logikalsolutions.com\\\/wordpress\\\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"C++ Arrays and Pointers Example\"}]},{\"@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++ Arrays and Pointers Example – Logikal Blog","description":"C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then . .","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\/arrays-and-pointers\/","og_locale":"en_US","og_type":"article","og_title":"C++ Arrays and Pointers Example – Logikal Blog","og_description":"C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then . .","og_url":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/","og_site_name":"Logikal Blog","article_published_time":"2023-11-27T20:06:17+00:00","article_modified_time":"2023-11-27T23:24:42+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":"5 minutes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#article","isPartOf":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/"},"author":{"name":"seasoned_geek","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"headline":"C++ Arrays and Pointers Example","datePublished":"2023-11-27T20:06:17+00:00","dateModified":"2023-11-27T23:24:42+00:00","mainEntityOfPage":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/"},"wordCount":572,"commentCount":1,"publisher":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#\/schema\/person\/c077f770ade13de7faaf616c3eac6842"},"image":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#primaryimage"},"thumbnailUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","keywords":["arrays","C++","pointers"],"articleSection":["Information Technology"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/","url":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/","name":"C++ Arrays and Pointers Example – Logikal Blog","isPartOf":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/#website"},"primaryImageOfPage":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#primaryimage"},"image":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#primaryimage"},"thumbnailUrl":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-content\/uploads\/2023\/11\/pexels-photo-6991812.jpeg","datePublished":"2023-11-27T20:06:17+00:00","dateModified":"2023-11-27T23:24:42+00:00","description":"C++ arrays and pointers really originate with the C programming language. There have been massive improvements since the 1980s. Back then . .","breadcrumb":{"@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/www.logikalsolutions.com\/wordpress\/information-technology\/arrays-and-pointers\/#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\/information-technology\/arrays-and-pointers\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https:\/\/www.logikalsolutions.com\/wordpress\/"},{"@type":"ListItem","position":2,"name":"C++ Arrays and Pointers Example"}]},{"@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\/6646","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=6646"}],"version-history":[{"count":0,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/posts\/6646\/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=6646"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/categories?post=6646"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.logikalsolutions.com\/wordpress\/wp-json\/wp\/v2\/tags?post=6646"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}