Editing Imperative programming (section)

===C===
[[C (programming language)|C programming language]] (1973) got its name because the language [[BCPL]] was replaced with [[B (programming language)|B]], and [[Bell Labs|AT&T Bell Labs]] called the next version "C." Its purpose was to write the [[UNIX]] [[operating system]].<ref name="cpl_3rd-ch2-37">{{cite book
  | last = Wilson
  | first = Leslie B.
  | title = Comparative Programming Languages, Third Edition
  | publisher = Addison-Wesley
  | year = 2001
  | page = 37
  | isbn = 0-201-71012-9
}}</ref> C is a relatively small language -- making it easy to write compilers. Its growth mirrored the hardware growth in the 1980s.<ref name="cpl_3rd-ch2-37"/> Its growth also was because it has the facilities of [[assembly language]], but uses a [[High-level programming language|high-level syntax]]. It added advanced features like:
* [[inline assembler]]
* arithmetic on pointers
* pointers to functions
* bit operations
* freely combining complex [[Operators in C and C++|operators]]<ref name="cpl_3rd-ch2-37"/>

[[File:Computer-memory-map.png|thumb|right|Computer memory map]]
''C'' allows the programmer to control in which region of memory data is to be stored. ''Global variables'' and ''static variables'' require the fewest [[Clock signal|clock cycles]] to store. The [[call stack|stack]] is automatically used for the standard variable [[Declaration (computer programming)|declarations]]. [[Manual memory management|Heap]] memory is returned to a [[Pointer (computer programming)|pointer variable]] from the [[C dynamic memory allocation|<code>malloc()</code>]] function.

* The ''global and static data'' region is located just above the ''program'' region. (The program region is technically called the ''text'' region. It's where machine instructions are stored.)
:* The global and static data region is technically two regions.<ref name="geeksforgeeks">{{cite web
| url = https://www.geeksforgeeks.org/memory-layout-of-c-program/
| title = Memory Layout of C Programs
| date = 12 September 2011
| access-date = 25 May 2022
| archive-date = 6 November 2021
| archive-url = https://web.archive.org/web/20211106175644/https://www.geeksforgeeks.org/memory-layout-of-c-program/
| url-status = live
}}</ref> One region is called the ''initialized [[data segment]]'', where variables declared with default values are stored. The other region is called the ''[[.bss|block started by segment]]'', where variables declared without default values are stored.
:* Variables stored in the ''global and static data'' region have their [[Memory address|addresses]] set at compile-time. They retain their values throughout the life of the process.

:* The global and static region stores the ''global variables'' that are declared on top of (outside) the <code>main()</code> function.<ref name="cpl-ch1-p31">{{cite book
 |title=The C Programming Language Second Edition
 |last1=Kernighan
 |first1=Brian W.
 |last2=Ritchie
 |first2=Dennis M.
 |publisher=Prentice Hall
 |year=1988
 |isbn=0-13-110362-8
 |page=31}}</ref> Global variables are visible to <code>main()</code> and every other function in the source code.

: On the other hand, variable declarations inside of <code>main()</code>, other functions, or within <code>{</code> <code>}</code> [[Block (programming)|block delimiters]] are ''local variables''. Local variables also include ''[[Parameter (computer programming)#Parameters and arguments|formal parameter]] variables''. Parameter variables are enclosed within the parenthesis of function definitions.<ref name="cpl_3rd-ch6-128">{{cite book
  | last = Wilson
  | first = Leslie B.
  | title = Comparative Programming Languages, Third Edition
  | publisher = Addison-Wesley
  | year = 2001
  | page = 128
  | isbn = 0-201-71012-9
}}</ref> They provide an [[Interface (computing)|interface]] to the function.

:* ''Local variables'' declared using the <code>static</code> prefix are also stored in the ''global and static data'' region.<ref name="geeksforgeeks"/> Unlike global variables, static variables are only visible within the function or block. Static variables always retain their value. An example usage would be the function <code>int increment_counter(){ static int counter = 0; counter++; return counter;}</code>

* The [[call stack|stack]] region is a contiguous block of memory located near the top memory address.<ref name="lpi-ch6-p121">{{cite book
 |title=The Linux Programming Interface
 |last=Kerrisk
 |first=Michael
 |publisher=No Starch Press
 |year=2010
 |isbn=978-1-59327-220-3
 |page=121}}</ref> Variables placed in the stack are populated from top to bottom.<ref name="lpi-ch6-p121"/> A [[Call stack#STACK-POINTER|stack pointer]] is a special-purpose [[processor register|register]] that keeps track of the last memory address populated.<ref name="lpi-ch6-p121"/> Variables are placed into the stack via the ''assembly language'' PUSH instruction. Therefore, the addresses of these variables are set during [[Runtime (program lifecycle phase)|runtime]]. The method for stack variables to lose their [[Scope (computer science)|scope]] is via the POP instruction.

:* ''Local variables'' declared without the <code>static</code> prefix, including formal parameter variables,<ref name="lpi-ch6-p122">{{cite book
 |title=The Linux Programming Interface
 |last=Kerrisk
 |first=Michael
 |publisher=No Starch Press
 |year=2010
 |isbn=978-1-59327-220-3
 |page=122}}</ref> are called ''automatic variables''<ref name="cpl-ch1-p31"/> and are stored in the stack.<ref name="geeksforgeeks"/> They are visible inside the function or block and lose their scope upon exiting the function or block.

* The [[Manual memory management|heap]] region is located below the stack.<ref name="geeksforgeeks"/> It is populated from the bottom to the top. The [[operating system]] manages the heap using a ''heap pointer'' and a list of allocated memory blocks.<ref name="cpl-ch1-p185">{{cite book
 |title=The C Programming Language Second Edition
 |last1=Kernighan
 |first1=Brian W.
 |last2=Ritchie
 |first2=Dennis M.
 |publisher=Prentice Hall
 |year=1988
 |isbn=0-13-110362-8
 |page=185}}</ref> Like the stack, the addresses of heap variables are set during runtime. An [[out of memory]] error occurs when the heap pointer and the stack pointer meet.

:* ''C'' provides the <code>malloc()</code> library function to [[C dynamic memory allocation|allocate]] heap memory.<ref name="cpl-ch8-p187">{{cite book
 |title=The C Programming Language Second Edition
 |last1=Kernighan
 |first1=Brian W.
 |last2=Ritchie
 |first2=Dennis M.
 |publisher=Prentice Hall
 |year=1988
 |isbn=0-13-110362-8
 |page=187}}</ref> Populating the heap with data is an additional copy function. Variables stored in the heap are economically passed to functions using pointers. Without pointers, the entire block of data would have to be passed to the function via the stack.