C++ Const

A name that must stay put

Write const before a type when that name should not be assigned again. The compiler treats a later write as an error. You get the mistake at compile time, not as a wrong answer after the program runs.

Use it for values that are facts in this program: a maximum score, a tax rate, a label you print in several places. If you need to change it, it is not const. Leave the keyword off and use a plain variable.

const variables

Initialize a const on the same line you declare it. There is no later chance to fill it in. After that, you may read it as often as you like.

#include <iostream>
using namespace std;

int main() {
  const int max_score = 100;
  int score = 88;
  cout << score << " / " << max_score << endl;
  return 0;
}

Why bother for a local int

For one integer in main, const looks optional. It pays off when the same name is used in several functions, or when a future edit might overwrite a limit by accident. Readers also see the intent: this is a fixed rule, not a running total.

Array sizes in this tutorial are compile-time constants. A const int used as a length is easier to change in one place than a magic 4 copied into a declaration and a loop bound.

#include <iostream>
using namespace std;

int main() {
  const int n = 4;
  int scores[n] = {88, 91, 74, 95};
  int total = 0;
  for (int i = 0; i < n; i++) {
    total += scores[i];
  }
  cout << total << endl;
  return 0;
}

const references as parameters

Pass by reference avoids a copy. Pass by const reference also promises the function will not assign through that name. The caller can pass an existing object without fear that the function will overwrite it.

This is the usual way to pass a string or a vector you only need to read. A copy would work and waste work. A plain vector<int>& would let the function callpush_back on the caller's vector. const vector<int>& forbids that.

#include <iostream>
#include <vector>
using namespace std;

int sum_of(const vector<int>& nums) {
  int total = 0;
  for (int n : nums) {
    total += n;
  }
  return total;
}

int main() {
  vector<int> nums = {3, 8, 4};
  cout << sum_of(nums) << endl;
  cout << nums.size() << endl;
  return 0;
}

const methods

A method marked const after its parameter list promises not to change the object. It may read fields and return them. It may not assign to them. Getters are the usual place for this.

The compiler enforces the promise. If get tried n = 0;, the class would not compile. Callers who only have a const object (or a const reference to one) can still call const methods.

#include <iostream>
using namespace std;

class Box {
  int n;
public:
  Box(int n_in) : n(n_in) {}
  int get() const { return n; }
  void set(int n_in) { n = n_in; }
};

int main() {
  Box b(7);
  cout << b.get() << endl;
  b.set(11);
  cout << b.get() << endl;
  return 0;
}

What const does not mean

const is not the same as a preprocessor #define. It is a typed name the compiler checks. It is also not a claim that the whole program is frozen: other variables can still change. Only that name is locked.

Mark what you only read

Start with const variables for fixed numbers, then const references for objects you pass in to inspect, then const on methods that only report state. Next: namespaces, which keep those names from colliding with someone else's n or get.