C言語の定数はdefineとconstどっち？違いと使い分け完全ガイド

2025年8月19日2025年12月2日

C言語

C言語では、定数を表現する方法として#defineマクロとconst変数がよく使われます。

しかし、この2つの違いを正しく理解していないと、バグを生みやすくなったり、読みづらいコードになってしまいます。

本記事では、「C言語の定数はdefineとconstどっちを使えばいいか」をテーマに、両者の仕組みと特徴、実践的な使い分けまで詳しく解説します。

目次 [ close ]

C言語の定数とは？基本とメリット

定数とは何か

定数(constant)とは、プログラムの実行中に値が変化しないものを指します。

C言語では、変数のように名前を付けた値であっても、途中で変更されないことが保証されている値を定数と呼びます。

代表的な定数の例として、次のようなものがあります。

円周率などの物理定数(PI = 3.14159...)
配列のサイズやバッファ長(BUFFER_SIZE = 1024)
エラーコード(ERR_INVALID_ARG = 1)
メッセージの最大文字数など、仕様として決まっている値

プログラム中で何度も同じ値を使う場合、その都度リテラル値(3.14や1024など)を書くのではなく、意味のある名前を付けて定数として定義することで、可読性と保守性が大きく向上します。

定数とリテラル値の違い

プログラム中に直接書かれた10や"hello"のような値は、リテラルと呼ばれます。

リテラルはそのままでも使えますが、意味づけがないため意図が伝わりにくいという欠点があります。

例えば、次のようなコードを見てください。

C言語

int buffer[1024];   /* 1024って何の数字？ */

これだけでは、1024という数字の意味がわかりません。

そこで、次のように定数として名前を付けると、意図が明確になります。

C言語

#define BUFFER_SIZE 1024
int buffer[BUFFER_SIZE];

このように、「意味のある名前を持つ値」として定数を定義することで、コードの理解が格段にしやすくなります。

定数を使うメリット

定数を使う最大のメリットは保守性と信頼性の向上です。

文章で順に見ていきます。

まず、定数を使うと値の変更箇所を1か所に集約できるようになります。

例えば、配列サイズやタイムアウトの時間などを仕様変更で変えたい場合でも、その定数定義だけを修正すれば、プログラム全体に変更が行き渡ります。

コード中に1024のような「マジックナンバー」を散らばらせてしまうと、見落としや修正漏れの原因になります。

また、定数は誤って値を書き換えることを防ぐという意味でも重要です。

意図せず値を変更してしまうバグは非常に厄介ですが、定数として宣言しておけば、そのようなミスをコンパイル時に検出できます(特にconstを使った場合に有効です)。

さらに、読みやすさの向上というメリットも見逃せません。

コードを読む人にとって、if (length > 1024)よりも、if (length > MAX_BUFFER_SIZE)の方が意図をすぐに理解できます。

まとめると、定数を使うメリットは次のように整理できます。

値を変更したいときに、定義部分だけ直せば済む
意図しない書き換えを防ぎ、バグを減らせる
コードの意味が伝わりやすくなり、読みやすくなる

C言語で定数を定義する方法一覧

C言語でよく使われる定数の定義方法を一覧として整理しておきます。

ここでは概要だけを表にまとめ、詳しい説明は後の章で行います。

方法	例	主な特徴
`#define`マクロ定数	`#define BUFFER_SIZE 1024`	コンパイル前に文字列置換される、型を持たない
`const`変数	`const int BufferSize = 1024;`	型を持つ読み取り専用変数、コンパイル時チェックあり
`enum`列挙体	`enum { MODE_READ = 1 };`	整数の列挙値に名前を付ける用途に適する
文字列リテラル	`const char *msg = "OK";`	実質的に定数扱いの文字列、書き換え不可が基本

この中でも特によく議論になるのが#defineとconstの違いです。

本記事の中心テーマでもありますので、次の章からそれぞれ詳しく見ていきます。

#defineによる定数定義の基礎

#defineマクロ定数の書き方と基本構文

#defineはプリプロセッサディレクティブであり、コンパイルの前段階で行われるテキスト置換の仕組みです。

もっとも基本的な定数定義は次のように書きます。

C言語

#define 定数名  置き換える値

例えば、最大接続数を表す定数をマクロで定義する場合は次のようになります。

C言語

#include <stdio.h>

/* 最大接続数を表すマクロ定数 */
#define MAX_CONNECTIONS 100

int main(void)
{
    /* MAX_CONNECTIONS はコンパイル前に 100 に置き換えられる */
    printf("最大接続数は %d です。\n", MAX_CONNECTIONS);
    return 0;
}

実行結果

最大接続数は 100 です。

ここで重要なのは、コンパイラがソースコードを読むときには、すでにMAX_CONNECTIONSという名前は存在せず、すべて100という文字列に置き換えられているという点です。

#defineで定義される定数の実体

#defineで定義した定数には「実体となる変数」が存在しません。

あくまで文字列の置換ルールが登録されているだけです。

次のコードを想像してみてください。

C言語

#define BUFFER_SIZE 1024

int main(void)
{
    int array[BUFFER_SIZE];
    return 0;
}

プリプロセッサ後のイメージは次のようになります。

C言語

int main(void)
{
    int array[1024];   /* 単に 1024 というリテラルに変わるだけ */
    return 0;
}

このように、コンパイル時点ではBUFFER_SIZEという名前は存在しないため、デバッガで変数一覧を見ても、BUFFER_SIZEという値を参照することはできません。

マクロには型がない

#defineで定義した定数には「型」という概念がありません。

そのため、次のように整数として使ったり浮動小数として使ったり、文脈次第で解釈が変わります。

C言語

#define VALUE 10

int i = VALUE;      /* int として使われる */
double d = VALUE;   /* double に暗黙変換される */

この柔軟さは便利な面もありますが、思わぬ型変換によるバグを生みやすいという欠点にもなります。

後で説明するconstとの重要な違いの1つです。

#define定数の型とスコープの特徴

スコープ(有効範囲)の基本

#defineマクロは、定義された地点より後に現れるソースコード全体で有効になります。

ただし、「ファイル単位」で有効である点に注意が必要です。

ヘッダファイルに次のように書くと、そのヘッダを#includeした全てのソースファイルで、定数が使えるようになります。

C言語

/* config.h */
#define BUFFER_SIZE 1024

C言語

/* main.c */
#include "config.h"

int buffer[BUFFER_SIZE];   /* 1024 に置換される */

一方、ローカルなスコープという概念はなく、一度定義すると、その後のコードすべてに影響を及ぼす点が特徴です。

ファイル単位・条件付きでの制御

スコープを制御するためには、#undefや条件付きコンパイルを併用します。

C言語

#define TEMP_VALUE 10

/* TEMP_VALUE を一時的に使う処理 */

#undef TEMP_VALUE   /* ここで以降TEMP_VALUEは無効になる */

また、複数のヘッダファイルで同じ名前を定義してしまうと、置換内容が意図せず上書きされることがあります。

そのため、ヘッダファイルでは「インクルードガード」を用いて多重定義を防ぐのが一般的です。

#defineでよくある書き方の例

単純な数値定数

C言語

#define MAX_USER_NAME_LEN  64
#define TIMEOUT_MSEC       5000
#define PI                 3.1415926535

名前は大文字とアンダースコアで書く慣習が多く、「これはマクロだ」と一目でわかるようにする目的があります。

文字や文字列の定数

C言語

#define NEWLINE_CHAR   '\n'
#define APP_NAME       "MyApplication"
#define DEFAULT_PATH   "/usr/local/app"

文字列や文字も、単なるテキスト置換です。

特にパスやメッセージなど、複数箇所で使う文字列に名前を付ける用途でよく使われます。

計算式を含むマクロ

C言語

#define KB(x)   ((x) * 1024)
#define MB(x)   ((x) * 1024 * 1024)

int size = KB(8);   /* 8 * 1024 に展開される */

このような引数付きマクロは、本記事の主題からは少し外れますが、定数と同様によく利用されます。

ただし、括弧の付け方を誤ると副作用を引き起こしやすいため、慎重に設計する必要があります。

constによる定数定義の基礎

const変数の書き方と基本構文

constは「変更不可」を意味する型修飾子です。

通常の変数宣言の前に付けることで、「あとから値を変更できない変数」を宣言できます。

C言語

#include <stdio.h>

int main(void)
{
    /* 読み取り専用の整数定数を定義 */
    const int MaxConnections = 100;

    printf("最大接続数は %d です。\n", MaxConnections);

    /* MaxConnections = 200;  // コンパイルエラーになる */

    return 0;
}

constで定義したものは、厳密には「定数」ではなく「変更禁止の変数」ですが、実務上は「定数」として扱われることがほとんどです。

constの位置と基本的な書き方

C言語では、次の書き方はいずれも同じ意味になります。

C言語

const int a = 10;
int const b = 20;

どちらも「変更できないint型の変数」です。

一般的には、const intという書き方を使うことが多いです。

constの型安全性とコンパイル時チェック

constの最大の利点は「型安全性」と「コンパイル時チェック」が効くことです。

型がはっきり決まる

次の例を見てください。

C言語

#define VALUE 10
const int ConstValue = 10;

double a = VALUE;       /* 暗黙の型変換、エラーにはならない */
double b = ConstValue;  /* こちらも暗黙変換だが、型はintとわかる */

マクロVALUEはその場に生の10が展開されるだけですが、ConstValueはint型の変数として扱われます。

この差は、関数の引数やポインタとの組み合わせで特に効いてきます。

例えば、間違った型の引数を渡そうとしたとき、constであればコンパイル時にエラーや警告として検出されます。

誤代入をコンパイル時に検出

constに対して代入しようとすると、コンパイルエラーとなります。

これはバグを早期に発見できるという意味で非常に重要です。

C言語

#include <stdio.h>

int main(void)
{
    const int Max = 10;

    int x = 5;
    x = Max;    /* OK: 読み取りは可能 */

    /* Max = 20;  // エラー: 読み取り専用オブジェクトに代入しようとした */

    return 0;
}

constのスコープ

const変数は、通常の変数と同じスコープルールに従います。

つまり、ブロックスコープとファイルスコープを持つことができます。

ローカルな定数

関数内で宣言すれば、その関数の中だけで有効な定数になります。

C言語

void func(void)
{
    const int LocalMax = 10;  /* func内だけで使用可能 */

    /* ... */
}

グローバルな定数

関数の外(ファイル先頭)で宣言すれば、そのファイル全体で有効な定数になります。

C言語

/* file1.c */
const int MaxUsers = 100;

他のファイルからも参照したい場合は、ヘッダファイルでextern宣言を行います。

C言語

/* config.h */
extern const int MaxUsers;

C言語

/* file1.c */
#include "config.h"
const int MaxUsers = 100;   /* 実体を定義 */

C言語

/* main.c */
#include "config.h"

int main(void)
{
    printf("%d\n", MaxUsers);   /* 他ファイルのconstを参照 */
}

このように、constは通常の変数と同じようにスコープとリンケージを制御できるため、大規模プログラムでも扱いやすい特徴があります。

constポインタなど注意したい書き方

constとポインタが絡むと、少し紛らわしくなります。

ここはC言語でつまずきやすいポイントなので、丁寧に整理します。

「指す先がconst」か「ポインタ自体がconst」か

よく出てくる2つのパターンは次の通りです。

C言語

const int *p;   /* 指す先のintがconst (読み取り専用) */
int * const p2; /* ポインタ自体がconst (別のアドレスを指せない) */

const int *p;
ポインタpが指すintの値は書き換えできませんが、pが指すアドレス自体は変更できます。
int * const p2;
p2が指す先のintは書き換え可能ですが、p2に別のアドレスを代入することはできません。

両方をconstにすることもできます。

C言語

const int * const p3;  /* 指す先もポインタ自体も変更不可 */

文字列とconst

文字列リテラルは、C言語の仕様上は書き換えてはいけないものです。

そのため、ポインタで受け取るときにはconst char *を使うのが望ましいです。

C言語

const char *msg = "Hello";

/* msg[0] = 'h'; // 未定義動作: 絶対にやってはいけない */

古いコードではchar *で受けている例も見かけますが、現在では警告の出る書き方として避けられることが多くなっています。

#defineとconstの違いと使い分け

ここまでで、#defineマクロとconst変数それぞれの基本を見てきました。

この章では、両者を直接比較しながら、実務的な使い分けの指針を整理します。

C言語におけるdefineとconstの主な違い一覧

まずは表で要点を比較します。

項目	#define	const
正体	プリプロセッサによるテキスト置換	型付きの「変更禁止変数」
型	なし	あり
スコープ	ファイル内(定義以降)	通常の変数と同じ(ブロック/ファイル/外部)
デバッガでの参照	原則不可(展開後は消える)	可能
コンパイル時チェック	弱い(文字列レベルの展開のみ)	強い(型や代入のチェックが行われる)
メモリ上の実体	原則なし(必要に応じて即値展開)	基本的には実体が存在(最適化で消えることも)
用途の典型	条件付きコンパイル、ビットフラグなど	通常の定数値、ポインタ経由の読み取り専用データ

もっとも重要なのは「型があるか」「テキスト置換か」という違いです。

これがデバッグのしやすさや安全性の差につながります。

デバッグ・エラー表示から見る違い

エラー位置とメッセージの違い

マクロとconstでは、エラーが発生したときのメッセージのわかりやすさも違ってきます。

C言語

#define DIVISOR 0

int divide(int x)
{
    return x / DIVISOR;   /* 実質的には x / 0; */
}

この場合、コンパイラはx / 0として扱うため、エラーメッセージや警告もそのように表示されます。

マクロ名DIVISORが直接メッセージに現れないことも多く、原因の追跡に手間取ることがあります。

一方、constの場合はどうでしょうか。

C言語

const int Divisor = 0;

int divide(int x)
{
    return x / Divisor;
}

コンパイラによっては、「Divisorという定数が0であるため除算できない」といった、より文脈に即したエラーや警告を出してくれることがあります。

また、デバッガでもDivisorの値を直接参照できるため、原因の特定がしやすくなります。

デバッガでの見え方

このように、デバッグのしやすさという点ではconstに軍配が上がることが多いです。

メモリ使用・最適化から見る違い

#defineは基本的に即値展開

#defineで定義した数値は、コンパイル後のコードには即値(リテラル)として埋め込まれるのが基本です。

したがって、メモリ上に「変数」として実体を持ちません。

C言語

#define LIMIT 10

int func(int x)
{
    if (x > LIMIT) {  /* 実際は if (x > 10) { ... } にコンパイルされる */
        /* ... */
    }
}

この場合、実行時にLIMITという変数を参照することはなく、CPU命令としては「レジスタ値と10を比較」のように生成されます。

constも最適化されれば即値になることが多い

一方、const変数は原則としてメモリ上に実体を持ちますが、最適化コンパイルを行うと、多くの場合は即値として扱われます。

C言語

const int Limit = 10;

int func(int x)
{
    if (x > Limit) {
        /* ... */
    }
}

最適化コンパイラは、Limitがプログラム中で決して書き換えられないことを理解しているため、実際には10という即値に置き換えてしまうことがよくあります。

その場合、実行時のオーバーヘッドはほとんどないと考えてよいでしょう。

大きな配列や構造体の場合

ただし、constで巨大な配列や構造体を定義した場合は、実際にメモリ上の領域を占有します。

C言語

const char Message[] = "This is a long message...";  /* 実体として配置される */

これはマクロ定数との明確な違いです。

メモリ消費を極力抑えたい極限環境(組み込みなど)では、この点も考慮して設計する必要があります。

enumと組み合わせた定数定義の考え方

C言語では、整数の定数に名前を付ける方法としてenum(列挙型)もよく利用されます。

C言語

enum ErrorCode {
    ERR_OK = 0,
    ERR_INVALID_ARG = 1,
    ERR_TIMEOUT = 2
};

enumの各メンバは整数の定数式として扱われ、配列のサイズなどにも使用できます。

C言語

int errorCount[ERR_TIMEOUT + 1];  /* 3要素の配列 */

enumのメリット

整数型としての型情報を持てる(特にC11以降やコンパイラ拡張で恩恵あり)
グループ化された関連定数をまとめて定義できる
デバッガによってはERR_TIMEOUTのような名前で表示してくれる

このように、「関連する整数の定数が複数ある場合」は、#defineよりもenumの方が構造化された表現になりやすいです。

C言語の定数はいつdefineを使うべきか

「では、#defineはもう使わない方がいいのか」という疑問が湧くかもしれません。

結論から言うと、用途を絞って使えば今でも有効な手段です。

条件付きコンパイルやビルド設定

#defineが最も威力を発揮するのは、条件付きコンパイルやビルド設定の切り替えです。

C言語

#define DEBUG 1

#if DEBUG
    printf("debug info: x = %d\n", x);
#endif

このような用途は、constでは代用できません。

プリプロセッサレベルで「コードを生成するかしないか」を制御するためです。

ビットフラグ・マスク値

ビット演算に用いるフラグやマスク値も、マクロ定数で定義されることが多いです。

C言語

#define FLAG_READ   (1u << 0)
#define FLAG_WRITE  (1u << 1)
#define FLAG_EXEC   (1u << 2)

ただし、この用途もenumやconst unsigned intで代替できる場合が多く、プロジェクトの方針によってはconstを推奨することもあります。

古いコードや規約に従う場合

既存のC言語プロジェクトでは、歴史的な理由やコーディング規約によって#defineを用いた定数定義が標準となっていることがあります。

そのような場合には、プロジェクトのルールに合わせつつ、新コードでは少しずつconstやenumへシフトしていく、という戦略も考えられます。

C言語の定数はいつconstを使うべきか

実務的には、「通常の定数値」を表したいときには、まずconstを検討するのがおすすめです。

型を伴う普通の定数

配列長や物理定数、閾値など、型がはっきりしている値は、constで定義すると安全です。

C言語

const int    MaxUserNameLen = 64;
const double Pi              = 3.141592653589793;
const int    TimeoutMsec     = 5000;

このように、型と意味がセットになった定数として宣言することで、関数の引数チェックや暗黙変換の抑制にも役立ちます。

配列・構造体の読み取り専用データ

言語リストやテーブルなど、複数要素からなる読み取り専用のデータは、constでまとめて定義するのが適しています。

C言語

typedef struct {
    int id;
    const char *name;
} ErrorInfo;

const ErrorInfo g_ErrorTable[] = {
    { 0, "OK" },
    { 1, "Invalid argument" },
    { 2, "Timeout" }
};

このような読み取り専用テーブルは、プログラム中で頻繁に参照されますが、書き換えられては困るデータです。

constを付けることで、誤変更をコンパイル時に防げます。

実践的な使い分けパターンとベストプラクティス

最後に、現場でよくあるパターンを踏まえた使い分けの指針を整理します。

パターン1: 通常の定数値はconstを優先

配列サイズ・物理定数・閾値・タイムアウト値などは、基本的にconstで定義するのが安全で扱いやすいです。

C言語

/* 推奨: constを使う */
const int    MaxConnection = 100;
const double Gravity       = 9.80665;

#defineで数値定数を乱用すると、型ミスやマクロ展開の副作用でバグが入り込みやすくなるため、まずはconstを検討する習慣を付けるとよいです。

パターン2: 関連する整数定数はenumでグループ化

エラーコードや状態コードなど、関連する整数値が複数ある場合は、enumでグループ化するとわかりやすくなります。

C言語

typedef enum {
    STATE_INIT,
    STATE_RUNNING,
    STATE_STOPPED
} State;

このとき、個々の値を#defineで書くのではなく、enumとして1か所にまとめることで、コードの構造が明確になります。

パターン3: プリプロセッサでしかできないことには#define

条件付きコンパイルや、ヘッダガード、プラットフォームごとの差分吸収など、プリプロセッサでしか実現できない制御には、迷わず#defineを使います。

C言語

#ifndef CONFIG_H_INCLUDED
#define CONFIG_H_INCLUDED

/* ヘッダの内容 */

#endif

これらの用途は、constでは代替できません。

パターン4: マクロ計算式は慎重に

引数付きマクロを「関数の代わり」として多用すると、デバッグが困難になります。

最近では、インライン関数やstatic関数で代替できるケースも多いため、可能な限りマクロの乱用は避けるのが無難です。

C言語

/* 非推奨になりがちな例 */
#define SQUARE(x)  ((x) * (x))

/* 可能ならインライン関数で */
static inline int square(int x) { return x * x; }

まとめ的指針

基本方針として、次のように考えると整理しやすくなります。

普通の定数値 → const
関連する整数のグループ → enum
コンパイル条件やビルド設定 → #define

この方針に沿っておけば、#defineとconstの使い分けで大きく迷う場面は少なくなります。

まとめ

C言語における定数定義では、#defineマクロとconst変数の違いを正しく理解し、用途に応じて使い分けることが重要です。

#defineはプリプロセッサによるテキスト置換であり型を持たないのに対し、constは型付きの変更禁止変数として、コンパイル時チェックやデバッグのしやすさで優れています。

実務では、通常の定数値にはconst、関連する整数にはenum、条件付きコンパイルには#defineという方針を基本としつつ、プロジェクトの規約や環境に合わせてバランスよく活用していくと、読みやすく安全なCコードを書きやすくなります。