Arrays and Strings

Arrays keep a fixed, ordered collection of values together. C strings use the same idea—an ordered character array—with one extra rule: a null character marks where the text ends. Learn the rules that make both useful instead of dangerous.

One contiguous collection, one explicit valid range

An array has a type, a capacity, and zero-based positions

int temperatures[5]; reserves five adjacent int elements. Its declared capacity is five, but the legal indexes are 0 through 4. The bracket expression selects one element: temperatures[0] is the first element and temperatures[4] is the fifth.

There is no automatic bounds check in ordinary C. temperatures[5] does not refer to a sixth element; it attempts to access memory outside the object. That is undefined behavior. It may seem to work, produce a surprising value, damage another variable, or fail later. Write the bound once, name it, and use it consistently.

Initialize the values you mean to have

An initializer list makes the first values explicit: int scores[5] = {16, 19, 14, 20, 18};. If the list is shorter than the declared capacity, the remaining elements are initialized to zero. This is useful for an all-zero array: int counters[12] = {0};.

The array capacity is separate from a runtime count. An array may have room for twelve results while a variable used says that only seven currently hold meaningful data. When that happens, loops should use used, not the full capacity.

#include <stdio.h>

int main(void) {
  int temperatures[5] = {18, 21, 15, 20, 19};
  int count = 5;
  int total = 0;

  for (int index = 0; index < count; index++) {
    total = total + temperatures[index];
  }

  printf("Total: %d\n", total);
  printf("Last reading: %d\n", temperatures[count - 1]);
  return 0;
}

Edit the program, predict its output, then run it.

Use index < count, never index <= count

For a sequence with count usable elements, the correct full traversal is for (int index = 0; index < count; index++). The first iteration uses index zero. The final iteration uses count - 1. Then the increment makes index equal to count, and the condition becomes false before an invalid access occurs.

#include <stdio.h>

int main(void) {
  int scores[4] = {14, 18, 16, 20};
  int count = 4;
  int total = 0;

  for (int index = 0; index <= count; index++) {
    total = total + scores[index];
  }

  printf("Total: %d\n", total);
  return 0;
}

Edit the program, predict its output, then run it.

Aggregate data without losing the type rule

A common pattern uses an accumulator initialized before the loop: int total = 0;. Each iteration updates it with one element. For a fractional average, ensure that one side of division is a double: double average = total / 5.0;. If both operands are int, C integer division discards any fractional part before the result is stored.

A function receives an array address, not its original length

When an array is passed to a function, the parameter acts like a pointer to its first element. The function can access elements, but it cannot reliably discover how many elements the caller created. Pass the count explicitly and preserve the same boundary contract inside the function.

int sum_scores(const int scores[], int count) {
  int total = 0;

  for (int index = 0; index < count; index++) {
    total += scores[index];
  }
  return total;
}

The const in const int scores[] documents that this function only reads the array. It protects callers from accidental element assignments inside the function. The array notation in the parameter improves readability, but the count is still required.

A C string is a character array terminated by \0

char city[16] = "Rabat"; creates a writable character array. The visible letters occupy positions 0 through 4; C places a terminating null character \0 at position 5. String-aware functions use that marker to know where text ends.

Capacity must include both the visible characters and the terminator. char city[6] = "Rabat"; fits exactly. char city[5] = "Rabat"; does not leave room for \0 and is invalid. A larger buffer is often intentional when you will later read or build longer text.

#include <stdio.h>

int main(void) {
  char city[16] = "Rabat";

  printf("City: %s\n", city);
  printf("First character: %c\n", city[0]);
  return 0;
}

Edit the program, predict its output, then run it.

Read and compare text with a capacity-aware policy

scanf("%s", city) is unsafe for a fixed buffer because it has no limit. For a char city[16] that reads one whitespace-delimited word, use a field width: scanf("%15s", city);. The width leaves one slot for \0. It stops at whitespace, so it is not suitable for a full city name with spaces.

For a line of text, prefer fgets(city, sizeof city, stdin). It receives the buffer and its capacity, and it can retain spaces. It may keep a trailing newline when there is room, so real programs often remove that newline deliberately before comparison or display.

Do not write through a pointer to a string literal

char city[] = "Rabat"; creates an array you can modify. By contrast, char *city = "Rabat"; points at a string literal. Treat that literal as read-only: assigning city[0] = 'r'; has undefined behavior. Use a character array whenever the program must change the characters.

Independent lab: publish a compact score report

Run the starter first. Then extend it without breaking the two boundaries: only access indexes from zero through count - 1, and only store text that fits inside report_name with its terminator. This browser runner covers the fixed-size declarations and indexed calculations; compile locally for function and input-library experiments.

#include <stdio.h>

int main(void) {
  char report_name[24] = "Practice results";
  int scores[5] = {16, 19, 14, 20, 18};
  int count = 5;
  int total = 0;

  for (int index = 0; index < count; index++) {
    total = total + scores[index];
  }

  double average = total / 5.0;
  printf("%s\n", report_name);
  printf("Total: %d\n", total);
  printf("Average: %f\n", average);
  return 0;
}

Edit the program, predict its output, then run it.

Lesson review

• A declared array capacity of count has valid indexes from 0 through count - 1.
• A full traversal uses index < count; index <= count accesses one element too far.
• Array out-of-bounds access is undefined behavior. C does not repair or safely clamp it.
• Pass an array's meaningful element count to every function that needs to process it.
• A C string is a character sequence ending in \0, so capacity must include one extra character.
• %s prints a complete terminated string; %c prints one character.
• Use field widths with scanf and prefer fgets for capacity-aware line input.
• Use strcmp to compare string contents, and write only into actual character arrays—not literals.