Array decay has nothing to do with too much sugar in your code or poor brushing habits. No, it’s a hot topic in C programming, and a source of confusion.
\n
\nArray decay is a byproduct of the tenuous relationship between arrays and pointers in the C language. It might be the reason why some programmers avoid pointers because the two are similar — to a degree.<\/p>\n
🗸 Arrays are not pointers.<\/p>\n
🗸 Pointers are not arrays.<\/p>\n
A connection exists between pointers and arrays, however, which is what array decay describes. The first element of an array, truly the array name itself, represents an address. The behavior is shown in the following code:<\/p>\n
\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n char str1[] = \"I am string one!\";\r\n char *str2 = \"I am string two!\";\r\n\r\n puts(str1);\r\n puts(str2);\r\n\r\n return 0;\r\n}<\/pre>\nVariable str1[]<\/code> is a character array, a string. So is variable str2<\/code>, though it’s declared as a pointer. Strings are declared either way in C. With str1[]<\/code>, you use array notation to access the individual characters (elements). With str2<\/code>, pointer notation is used. (Also, str2<\/code> has its own quirks, which I discuss here<\/a>.)<\/p>\nBoth variables are used in the same manner with the puts()<\/em> function to output the strings:<\/p>\nI am string one!
\nI am string two!<\/code><\/p>\nThe compiler sees both str1[]<\/code> and str2<\/code> as addresses, the location in memory where a string is stored. This effect is how array decay works: The first element in an array “decays” to a pointer. The element isn’t specified directly. If you try the statement puts(str1[0]<\/code>), the compiler generates a warning as str1[0]<\/code> is a single character and not a string. Running the program results in Bad Things happening.<\/p>\nThe following code also shows array decay in action, where the array is assigned to a pointer:<\/p>\n
2025_09_06-Lesson-b.c<\/a><\/h3>\n\r\n#include <stdio.h>\r\n\r\nint main()\r\n{\r\n int array[] = { 10, 20, 30, 40 };\r\n int *ptr;\r\n\r\n ptr = array;\r\n printf(\"%d\\n\",*ptr);\r\n\r\n return 0;\r\n}<\/pre>\nDue to the array decay, the statement ptr = array<\/code> works; the array’s base address is saved in int<\/em> pointer ptr<\/code>. Further, the pointer is used in the printf()<\/em> statement to output the value of the array’s first element, 10.<\/p>\nThe code could further use the pointer to reference other elements in the array. For example, *(ptr+3)<\/code> references the fourth array element, 40.<\/p>\nThis witchery doesn’t work in reverse. You cannot use an array to dig into a pointer’s buffer. After all, the effect is called “array decay” and not “whacky pointer things.”<\/p>\n
Where array decay comes in handy is when dealing with arrays and functions. I explore this aspect of array decay in next week’s Lesson<\/a>.<\/p>\n","protected":false},"excerpt":{"rendered":"Have you discussed array decay with your Dentist? Because if you have, you’re wasting your time. Continue reading