![\"graphic\"](\"https:\/\/c-for-dummies.com\/blog\/wp-content\/uploads\/2020\/08\/0822-figure1-1.png\")
\nLike all variables in C, arrays are declared uninitialized. They contain whatever junk already exists in memory. Initializing an array is therefore important. It can be done in one of three ways: as it’s declared, in a loop, or as it’s used in the code.
\n
\nDeclaring an array involves assigning it a data type, name, and size:<\/p>\n
Array Integer array In this format, integer array Array This initialization trick works only for zero. if you initialize the array at Line 6 with this statement:<\/p>\n The output looks like this:<\/p>\n The first (zeroth) element is 1.0, but the rest are zero. I really wish all the elements were initialized to the same value, but that’s not how it works.<\/p>\n If it’s your desire to initialize an array to a specific value, run a loop that sets all the array’s values. This is the approach I use in my code:<\/p>\n The for<\/em> loop at Line 9 initializes all values in the array to -1. That’s it. Output:<\/p>\n I’ve read online that the gcc<\/em> compiler offered a non-standard initialization alternative. It uses an ellipses in the square brackets to assign a set value to a range of elements. The format looks something like this:<\/p>\n The brackets in the assignment specify a range from 1 to 10 elements (or it should be 0 to 9?). These elements are given the value 1.0. On my systems, the gcc<\/em> compiler doesn’t support this trick. Even so, if it works, it’s non-standard and I wouldn’t recommend it.<\/p>\n The It’s a basic operation because, unless you don’t initialize the array, it contains garbage. Continue reading float market_close[5];<\/code><\/p>\nmarket_close<\/code> is composed of 5 float<\/em> values. This declaration merely sets aside storage for the values; nothing is initialized.<\/p>\nint scores[] = { 1075, 1050, 975, 850, 600 };<\/code><\/p>\nscores<\/code> contains 5 elements, defined as the array is declared. The number 5 isn’t required in the brackets because the compiler is smart enough to figure out that 5 elements are declared.<\/p>\nint scores[5] = { 0 };<\/code><\/p>\nscores<\/code> contains five elements, all zero. The { 0 }<\/code> initialization applies to all five elements. The following code shows how this trick works for a floating-point array.<\/p>\n2020_08_22-Lesson-a.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n const int size = 10;\r\n float v[size] = { 0.0 };\r\n\r\n puts(\"Array Dump\");\r\n for(int x = 0; x<size; x++ )\r\n printf(\"%2d: %f\\n\",x+1, v[x] );\r\n\r\n return(0);\r\n}<\/pre>\nv<\/code> is declared at Line 6 and initialized to size<\/code> (10) float<\/em> values. The dump at Lines 9 and 10 outputs the array’s values:<\/p>\nArray Dump
\n 1: 0.000000
\n 2: 0.000000
\n 3: 0.000000
\n 4: 0.000000
\n 5: 0.000000
\n 6: 0.000000
\n 7: 0.000000
\n 8: 0.000000
\n 9: 0.000000
\n10: 0.000000<\/code><\/p>\nfloat v[size] = { 1.0 };<\/code><\/p>\nArray Dump
\n 1: 1.000000
\n 2: 0.000000
\n 3: 0.000000
\n 4: 0.000000
\n 5: 0.000000
\n 6: 0.000000
\n 7: 0.000000
\n 8: 0.000000
\n 9: 0.000000
\n10: 0.000000<\/code><\/p>\n2020_08_22-Lesson-b.c<\/a><\/h3>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n const int size = 10;\r\n int v[size];\r\n\r\n \/* initialize array *\/<\/span>\r\n for(int x = 0; x<size; x++ )\r\n v[x] = -1;\r\n\r\n \/* output array *\/<\/span>\r\n puts(\"Array Dump\");\r\n for(int x = 0; x<size; x++ )\r\n printf(\"%2d: %d\\n\",x+1, v[x] );\r\n\r\n return(0);\r\n}<\/pre>\nArray Dump
\n 1: -1
\n 2: -1
\n 3: -1
\n 4: -1
\n 5: -1
\n 6: -1
\n 7: -1
\n 8: -1
\n 9: -1
\n10: -1<\/code><\/p>\nfloat v[10] = { [1 . . . 10] 1.0 };<\/code><\/p>\n= { 0 }<\/code> initialization format is available for array initialization, but I still prefer to use a loop to set clean all the elements’ values. It’s not that I don’t trust the compiler but . . . No, wait. I don’t trust the compiler. Yeah, just initialize your arrays. It’s a good thing.<\/p>\n","protected":false},"excerpt":{"rendered":"