○newとdelete

Ｃ言語編で動的なメモリ確保について説明しました。そのとき使ったのが、malloc関数とfree関数でした（第５５章参照）。C++でも、もちろんこれらの関数を使用して動的なメモリ確保が行えますが、通常は使いません。代わりに使われるのが、この章で紹介する new演算子とdelete演算子です。

new演算子を使うとメモリの動的確保が行え、delete演算子によって解放することができます。ここで注意してほしいのですが、newとdeleteは演算子です。mallocやfreeは関数です。この違いには重要な意味があるのですが、現段階では知る必要はありません（第１７章で演算子のオーバーロードについて説明しますが、これと関係します）。

○newとdeleteを使う

まずは単純にint型１つ分の領域を動的確保してみます。

#include <iostream>

int main()
{
        int *p;
        
        p = new int();  // int型の領域を動的確保
        *p = 123;
        std::cout << *p << std::endl;
        
        delete p;       // 動的に確保した領域を解放
        
        return 0;
}

new演算子は、その直後に書いた型の領域を確保します。上の例ならint型になります。intの直後に付いている括弧には、コンストラクタに渡す引数を指定できます。new演算子は、メモリの確保と共に、コンストラクタを呼び出します。実はC++では、int型のような基本データ型にもコンストラクタがあります。試しに、( )の中に123と書き、直後の *p = 123;　をコメントアウトして試してみると、確かに123と出力されます。よってC++では、次のどの方法を使っても、初期化処理が行えます。

int num = 100;
int num(100);
p = new int(100);

もちろん3つ目の方法では、pがポインタですし、使い終わったらにdeleteを呼ぶ必要があります。ついでに話しておくと、C++では「代入」と「初期化」は異なります。コンストラクタが呼び出されるのは「初期化」のときです。

delete演算子の使い方は、newで確保した領域を指すポインタを、deleteの直後に記述するだけです。newで確保した領域でないと解放は行えません（malloc関数で確保した領域をdeleteで解放してはいけない）。なお、NULL で初期化されているポインタをdelete演算子に指定すると、何も起こらないことが保証されています。

new演算子がコンストラクタを呼び出しているのと同じで、delete演算子はデストラクタを呼び出します。

○配列を使う

次にnew演算子を使って、配列用の領域を確保してみます。

#include <iostream>

int main()
{
        int *p;
        int i;
        
        p = new int[10];  // int型10個分の領域を動的確保
        for(i=0; i<10; ++i)
        {
                p[i] = i;
                std::cout << p[i] << std::endl;
        }
        
        delete [] p;       // 動的に確保した領域を解放
        
        return 0;
}

new演算子を使って配列を確保するには、型指定の直後に[]を使って、配列に含まれる要素数を指定します。上の例を見て分かるように、配列を動的確保する場合に()はありません。つまり、コンストラクタに引数を渡せません。配列を動的確保する場合、コンストラクタは呼び出されないのではなく、引数がないデフォルトのコンストラクタが呼び出されています。このように、呼び出すコンストラクタを指定しなかった（できなかった）場合に、呼び出される、引数のないコンストラクタをデフォルトコンストラクタといいます。あるクラスに関して、１つも明示的にコンストラクタを宣言していない場合、コンパイラが自動的にデフォルトコンストラクタ生成します。１つでもコンストラクタを宣言している場合には、このような自動的な生成は行われません。

重要なのはdelete演算子の使い方です。new演算子を使って配列を確保した場合、delete演算子にも[]を付けなければなりません。これを付けないと、正しく解放できません（恐らく、配列の先頭の要素についてだけ解放されるが、それすらも保証されている訳ではない）。この[]の付け忘れは非常によくある間違いです。コンパイルは普通に成功してしまうので気をつけて下さい。

○newでインスタンス化

もちろん、new演算子を使ってクラスをインスタンス化できます。

#include <iostream>

int main()
{
	CSample* p;
	
	p = new CSample( 100 );
	std::cout << p->Get() << std::endl;
	delete p;
	
	return 0;
}

使い方は全く同じです。当然、コンストラクタを呼び出せます（クラスを配列としてインスタンス化する場合は除く）。 new演算子を使ってインスタンス化する場合、そのメンバ変数やメンバ関数をアクセスするときに、アロー演算子を使うことになります。まあポインタ経由のアクセスになるので、当然といえば当然です。

delete演算子についても特殊なことはありません。ここでも[ ]を付けるか付けないかには注意が必要です。

○malloc関数を使わない理由

C++では通常、malloc関数（callocやreallocも含む）を使いません。その理由は簡単で、malloc関数ではコンストラクタが呼び出せないからです。デフォルトコンストラクタも呼び出されません。同様に、free関数ではデストラクタが呼び出されません。

extern指定子を付けると
「宣言が他の場所にも書かれている」ことをコンパイラに知らせることができます。
コンパイラはexternが付いていることを発見すると
他の場所で同様の名前で宣言されている変数を見つけてもエラーを出しません。
なお、定義はプログラム中で１箇所だけしか許されないので
ソースファイルの側に記述しておきます。
このとき、そのソースファイルが、宣言の記述されているヘッダファイルを
インクルードしている必要があります（正確には、宣言が見える位置に定義を書かなければならない）。
なお、extern指定子は、関数プロトタイプに付けることもできますが
関数に関しては付けなくても問題はありません。
（元々定義はソースファイル側の１箇所にしかないはずだから）。

以上　Programing Place内より引用
================================

gets_s 関数は、stdin 標準入力ストリームから行を読み取り、buffer に格納します。
行は最初の改行文字 (\n) までのすべての文字で構成されています。
その後、gets_s は、改行文字を null 文字 (\0) に置換してから行を返します。
これとは対照的に、fgets_s 関数は改行文字を保持します。

最初に読み取られた文字がファイルの終端の文字である場合
null 文字が buffer の先頭に格納され、NULL が返されます。

ワイド文字を扱う場合は、gets_s ではなく _getws を使用します。
引数にはワイド文字列を指定します。また戻り値もワイド文字列です。

buffer が NULL の場合、sizeInCharacters が 0 以下の場合
またはバッファが小さすぎて入力行と終端の null を格納できない場合
これらの関数は「パラメータの検証」（←NCDMライブラリ　内より引用）に説明されているように
無効なパラメータ ハンドラを呼び出します。実行の継続が許可された場合
これらの関数は NULL を返し、errno を EINVAL に設定します。

C++ では、これらの関数の使用はテンプレートのオーバーロードによって簡素化されます。
オーバーロードでは
バッファ長を自動的に推論できる (サイズの引数を指定する必要がなくなる) だけでなく
古くてセキュリティが万全ではない関数を新しく安全な関数に自動的に置き換えることができます。

以上　MSDNライブラリ　内より引用
=================================

/* try001.c */

#include <stdio.h>
#include <limits.h>

int main()
{
        printf( "%d\n", INT_MAX );
        
        return 0;
}

整数型の大きさを表すマクロの定義。

• CHAR_BIT - char 型を構成するビット数（≧8）
• MB_LEN_MAX - 処理系がサポートするマルチバイト文字の最大バイト数
• CHAR_MAX - char 型の最大値。 SCHAR_MAX または UCHAR_MAX と同じ
• CHAR_MIN - char 型の最小値。 SCHAR_MIN または 0 と同じ
• SCHAR_MAX - signed char 型の最大値（≧127）
• SCHAR_MIN - signed char 型の最小値（≦-127）
• UCHAR_MAX - unsigned char 型の最大値（≧255）
• SHRT_MAX - short 型の最大値（≧32767）
• SHRT_MIN - short 型の最小値（≦-32767）
• USHRT_MAX - unsigned short 型の最大値（≧65535）
• INT_MAX - int 型の最大値（≧32767）
• INT_MIN - int 型の最小値（≦-32767）
• UINT_MAX - unsigned int 型の最大値（≧65535）
• LONG_MAX - long 型の最大値（≧2147483647）
• LONG_MIN - long 型の最小値（≦-2147483647）
• ULONG_MAX - unsigned long 型の最大値（≧4294967295）

memcpy()は、メモリ上の指定した位置にあるデータを、他の位置にコピーする 関数。

void* memcpy(void* s1, const void* s2, size_t n);

第１引数がコピー先領域の先頭アドレス、第２引数がコピー元領域の先頭アドレスです。
第３引数には、コピーするデータの大きさをバイト単位で指定します。
戻り値には、第１引数で指定したアドレスがそのまま返されます。

memset()のところで触れたように、メモリ操作系の関数は、文字列操作関数と似ています。
memcpy()の文字列専用バージョンがstrcpy()ということになります。
memcpy()の方が、引数が１つ増えていて、そこにデータの大きさを指定するようになっています。
これは、文字列の場合なら、末尾に'\0'があることを前提としているため
データの大きさを指定しなくても、自動的に末尾を判定できるためです。
memcpy()は、どんな種類のデータにでも対応できる反面
データサイズを具体的に指定する必要があります。
memcpy()は、データサイズを指定するため
何らかの理由で末尾に'\0'のない文字列のコピーにも利用できることを忘れないで下さい。
文字列のコピーには
必ずしも strcpy()を使わなければならないということはありません。

ここでは、文字列の途中に'\0'が登場していても
memcpy()ならコピー可能であることを確かめてみましょう。

#include <stdio.h>
#include <string.h>

int main(void)
{
        char str[12] = "abcde\0fghij";  /* 途中に\0がある */
        char out[12];
        int i;
        
        memcpy( out, str, 12 );  

        /* strからoutへコピー *//* 結果を出力 */
        for( i = 0; i < 12; ++i )
        {
                printf( "%c", out[i] );
        }
        
        return 0;
}

出力される結果は、

abcde fghij

となります。'\0'はヌル文字なので、出力するとその部分が空白になっていることが分かります。
そして、それより後ろにあるfghijも正しく出力できています。

さて、もう１つプログラム例を見て下さい。

#include <stdio.h>
#include <string.h>

int main(void)
{
        char str[6] = "abcde";
        int i;
        
        memcpy( &str[2], str, 3 );  

        /* "abc"の部分を"cde"の部分にコピー？ *//* 結果を出力 */
        for( i = 0; i < 6; ++i )
        {
                printf( "%c", str[i] );
        }
        printf( "\n" );
        
        return 0;
}

今回のコピー元は配列strの先頭、コピー先は同じ配列の３文字目の部分になっています。
そして、コピーする大きさは３バイトです。
元の配列には"abcde"が格納されているので、この実行結果は

ababc

となることを期待するでしょう。しかし、実行結果は次のようになる場合もあります。

ababa

memcpy()の重要な注意点がこれです。
つまり、コピー元の範囲と、コピー先の範囲との一部が重なっている場合には
memcpy()は正しく動作しないかも知れません。
今回の場合、str[2]の部分が重なってしまっているので、このようなことが起こります。
もし、領域が重なってしまっている場合には、memcpy()ではなくmemmove()を使います。

先ほどから「場合もあります」とか「かも知れません」と書いていますが
これはコンパイラの実装による部分なので、どうなるかは分かりません。
例えば、VisualC++2005やVisualC++.NET2003で確認すると
上のプログラムは期待した通り"ababc"と出力します。
Borland C++ Compliler5.5.1で確認すると、"ababa"を出力しました。

以上　Programing Place内より引用
=================================

パラメータ

dest：コピー先のバッファ。

numberOfElements：コピー先のバッファのサイズ。

src：コピー元のバッファ。

count：コピーする文字数。

NULLとは

NULLの欠点

NULLの代用

0の問題

先端技術応用null

const class {
public:
    template<class T>
    operator T*() const { return 0; }
    // あらゆる型のメンバポインタへの変換
    template<class C, class T>
    operator T C::*() const  { return 0; }
private:
    void operator&() const;
} null; 

変換指定は次の形式をとる。（[ ]内は省略可能）

%[フラグ][最小フィールド幅][.精度][長さ修飾子]変換指定子

フラグ

変換指定のフラグは以下の通り。

長さ修飾子

変換指定子

strcpy_s() 関数は、より安全にコピーを行うために
コピー先バッファのサイズも引数としてとる(「STR07-C. TR 24731 を使用し
文字列操作を行う既存のコードの脅威を緩和する」参照)。

int main(int argc, char *argv[]) {
  /* ... */
  char * prog_name;
  size_t prog_size;

  prog_size = strlen(argv[0])+1;
  prog_name = (char *)malloc(prog_size);

  if (prog_name != NULL) {
    if (strcpy_s(prog_name, prog_size, argv[0])) {
      /* strcpy_s() のエラーを処理 */
    }
  }
  else {
    /* メモリを確保できなかった場合のエラー処理 */
  }
  /* ... */
}

strcpy_s() 関数を使うことで
動的に割り当てられたメモリまたは静的に割り当てられた配列との間でデータをコピーできる。
十分な領域がない場合、strcpy_s() はエラーを返す。

以上　JPCERT コーディネーションセンター　内より引用
=================================================


==========================================

ちょっと過激なタイトルだが．．．Visual Studio 2005でstrcpyを使うと以下のような警告が出る。

void	Test(void)
{
	char	pszText[256];

strcpy(pszText,"あいうえお");
}

「warning C4996: 'strcpy' が古い形式として宣言されました。
'strcpy' の宣言を確認してください。」というのはあくまでも警告であってエラーではない。
そのため．．．

#define _CRT_SECURE_NO_DEPRECATE

#define WIN32_LEAN_AND_MEAN // Windows ヘッダーから使用されていない部分を除外します。
// Windows ヘッダー ファイル:
#include <windows.h>

// C ランタイム ヘッダー ファイル
#include <stdlib.h>
#include <malloc.h>
#include <memory.h>
#include <tchar.h>

void Test(void)
{
char pszText[256];

strcpy(pszText,"あいうえお");
}

というように「_CRT_SECURE_NO_DEPRECATE」の定義を一番初めにおこなっておけば
この警告は出ないし、プログラムもきちんと動く。
しかし、だからと言ってこれは警告を無視しているだけであって根本的な問題は何も変わっていない。

strcpyを使うと何が問題なのかと言うと、コピー先のバッファー容量が指定されていない点だ。
つまり

void	Test(void)
{
	//1バイトしか確保していない！
	char	pszText[1];

//8バイトも代入してる！
strcpy(pszText,"abcdefg");
}

こんなソースコードを動かしたときにいわゆるバッファーオーバーランという状態になる。

デバッグ環境であれば

こんなエラー画面が表示されてプログラムが途中で止まるし
リリースコードでは悪意を持った者の攻撃対象となりうる。

正直なところを言うと
普通のフリーソフトを作っている開発者や趣味でプログラミングをしている人
仕事であってもカスタムソフト的なこじんまりしたソフトを作っている場合には
そこまで考えてプログラムする必要はないと思う。
しかし最近は小さいソフト会社でも「セキュリティが高いソフト」を開発しているとうたっている。
内容をよくよく聞いてみると「保存データを暗号化してるからセキュリティが高い」とか
「SSLで通信してるからセキュリティが高い」というような感じで
ソフト全体の開発にセキュリティを意識しているというわけではなく
ほんの一部分だけセキュリティを意識しただけで
実は全然セキュリティが高くないソフトを販売していたりする。
今後セキュリティが少しでも高いソフトウエアを開発したいと思っている場合は
まずは手始めにstrcpyの使用で出るような警告部分を修正するといいだろう
（ちなみに私はセキュリティが本当に高いソフトを開発するだけの能力は
持ち合わせていないのでこんなことを書いていいものかとも思うのだが．．．）。

ではどのようにすれば警告が出なくなり（少しは）安全なソースコードになるかと言うと

void	Test(void)
{
	char	pszText[256];

strcpy_s(pszText,256,"あいうえお");
}

このようにstrcpyの代わりにstrcpy_sという関数を利用する。
この関数では第二引数にpszTextで確保されている大きさを渡すようにできている。
これにより、strcpy_s内部では文字列をコピーする前に
コピー先に十分な領域があるかをチェックすることができ
バッファーオーバーランを未然に防ぐことができる。

とは言うものの以下のようにするとやはり文字列のコピーに確保された容量が足りないため
エラーになることはなる。
しかしデバッグビルドではアサーションエラー、リリースビルドでは
単に強制終了になるなどバッファーオーバーランよりはましだ。

void	Test(void)

{

        char    pszText[1];

strcpy_s(pszText,1,"あいうえお");
}

strcpyに対してstrcpy_sが作られたように
wcscpyにはwcscpy_s、_tcscpyには_tcscpy_sが用意されている。
また、同じようにstrncpyにもstrncpy_s、_tcsncpyに_tcsncpy_s．．．
従来の関数名に「_s」を付加したものがある。
警告が出たときは無視せずに置き換えるようにしよう。

以上　UsefullCode.net　内より引用（画像は略）
==========================================

定義

 size_t strlen(const char* str); 

strlen関数は引数strの文字数を返す関数です．
ただし文字列の最後のNULL文字はカウントに含まれません．
size_tというのはunsigned intとほぼ同じです． (環境依存なのでunsigned intとは限りません.)

#include <stdio.h>
#include <string.h>

int main(void)
{
        char source[20] = "hello";
        printf("文字列の長さは %d です\n", strlen(source) );
        return 0;
}

実行結果

 文字列の長さは 5 です

 char* strncat(char* str1, const char* str2, size_t n);

strncat関数は文字列str1の後ろにstr2の文字列をn文字分連結させる関数です．

#include <stdio.h>
#include <string.h>

int main(void)
{
    char dest[20] = "ABC";
    char source[20] = "DEFGH";

    strncat(dest, source, 3);
    printf("文字列：%s\n", dest); 
    return 0;
}

実行結果

 文字列：ABCDEF

STR07-C. TR 24731 を使用し、文字列操作を行う既存のコードの脅威を緩和する

ISO/IEC TR 24731 は、C の既存の標準関数に代わり
より安全に利用できるように設計された代替関数を規定している。
たとえば、ISO/IEC TR 24731 Part I (24731-1) は、strcpy()、strcat()、strncpy()
および strncat() の代替関数として
それぞれ strcpy_s()、strcat_s()、strncpy_s() および strncat_s() 関数を定義している。

ISO/IEC TR 24731-1 関数は
過去 10 年間に起きた広く知られている多数のセキュリティインシデントに対応して
レガシーコードの改善に役立てる目的で Microsoft によって作成された。
これらの関数はその後
プログラミング言語 C の国際標準化ワーキンググループ(ISO/IEC JTC1/SC22/WG14)へ
標準化のために提案された。

たとえば、strcpy_s() の関数原型は次のとおりである。

errno_t strcpy_s(
  char * restrict s1,
  rsize_t s1max,
  const char * restrict s2
);

関数原型は strcpy() に似ているが
コピー先バッファの最大長を指定する rsize_t 型の引数を 1 つ余分に取る。
(rsize_t 型の引数を取る関数は、引数の値が RSIZE_MAX を超えている場合に制約違反と診断する)。
極端に大きなオブジェクトサイズは
オブジェクトのサイズが正しく計算されなかったことを示していることが多い。
たとえば、負の数は、size_t のような符号なしの型に変換されたときに非常に大きな正の数となる。
このような理由から、オブジェクトサイズの範囲を制限してエラーを検出することが有効な場合がある。
アドレス空間が大きなマシンの場合、ISO/IEC TR 24731-1 は
RSIZE_MAX を、サポートされている最も大きなオブジェクトのサイズまたは (SIZE_MAX >> 1) のうち
小さいほうの値として定義することを推奨している。
これは、たとえこの制限が、正当な(ただし非常に大きい)オブジェクトよりも小さくてもである。
(「INT01-C. オブジェクトのサイズを表すすべての整数値には rsize_t または size_t を使用する」も参照)。

strcpy_s() は、意味規則も strcpy() に似ている。
入力違反エラーがなければ、strcpy_s() 関数はコピー元の文字列からコピー先の文字配列へ
終端の NULL 文字までの文字を NULL 文字も含めてコピーする。
この関数は、成功するとゼロを返す。

strcpy_s() 関数は、コピー元の文字列をコピー先へ
コピー先バッファをオーバーフローさせずに完全にコピーできた場合に限り成功する。
具体的には以下のチェックが行われる。

・コピー元とコピー先のポインタが NULL であるか。
・コピー先バッファの最大長が、ゼロか、RSIZE_MAX よりも大きいか
　またはコピー元文字列の長さ以下であるか。
・領域の重なり合うオブジェクト間のコピーはできない。

実行時制約違反が検出された場合、コピー先バッファが NULL ポインタではなく
その最大長が、ゼロよりも大きく RSIZE_MAX 以下であれば
コピー先文字列は NULL 文字列に設定され、関数はゼロ以外の値を返す。
次の例では、strcpy_s() 関数を使用して src1 を dst1 にコピーしている。

char src1[100] = "hello";
char src2[8] =  {'g','o','o','d','b','y','e','\0'};
char dst1[6], dst2[5];
int r1, r2;

r1 = strcpy_s(dst1, sizeof(dst1), src1);
r2 = strcpy_s(dst2, sizeof(dst2), src2);

しかし、8 文字からなる文字列全体をコピー先バッファにコピーするための十分な領域がないため
src2 を dst2 にコピーする呼び出しは失敗する。
結果として、r2 にはゼロ以外の値が代入され、dst2[0] には NULL 文字が設定される。

ISO/IEC TR 24731-1 関数を使用すると
コピー先バッファのサイズと追加される文字の最大数を指定する必要があるため
セキュリティ上の欠陥を引き起こす可能性は低い。
ISO/IEC TR 24731 Part II (24731-2、策定中) では、もう 1 つの方法として
関数の結果に対して十分なメモリを割り当てる関数が提案される予定である。
ISO/IEC TR 24731 関数は、コピー先文字列の NULL 終端も保証する。

ただし ISO/IEC TR 24731-1 関数を使ったとしても
コピー先バッファの最大長およびコピーする文字の数が間違って指定された場合
依然としてバッファオーバーフローを引き起こす可能性はある。
ISO/IEC TR 24731-2 関数を使うと解放しなくてはならないメモリを把握しずらくなり
メモリリークを引き起こすおそれがある。
それゆえ ISO/IEC TR 24731 関数は特別安全なわけではないが
脆弱性の予防を目的とした保守に用い、レガシーコードの脆弱性を低減する役には立つだろう。

違反コード

次のコードは、msg が長すぎる場合にバッファオーバーフローを引き起こし
msg が NULL ポインタの場合に未定義の動作を引き起こす。

void complain(const char *msg) {
  static const char prefix[] = "Error: ";
  static const char suffix[] = "\n";
  char buf[BUFSIZ];

  strcpy(buf, prefix);
  strcat(buf, msg);
  strcat(buf, suffix);
  fputs(buf, stderr);
}

適合コード (実行時検査)

次の解決法では、バッファオーバーフローは生じない。

void complain(const char *msg) {
  errno_t err;
  static const char prefix[] = "Error: ";
  static const char suffix[] = "\n";
  char buf[BUFSIZ];

  err = strcpy_s(buf, sizeof(buf), prefix);
  if (err != 0) {
    /* エラー処理 */
  }

  err = strcat_s(buf, sizeof(buf), msg);
  if (err != 0) {
    /* エラー処理 */
  }

  err = strcat_s(buf, sizeof(buf), suffix);
  if (err != 0) {
    /* エラー処理 */
  }

  fputs(buf, stderr);
}

適合コード (コンパイル時に部分的に検査)

次の解決法は、静的アサートを使用して
コンパイル時にいくつかのチェックを行っている。
(「DCL03-C. 定数式の値をテストするには静的アサートを使う」を参照)。

void complain(const char *msg) {
  errno_t err;
  static const char prefix[] = "Error: ";
  static const char suffix[] = "\n";
  char buf[BUFSIZ];

  /* 2 文字以上が
   * msg のために用意されていることを保証する。 */
  static_assert(sizeof(buf) > sizeof(prefix) + sizeof(suffix),
                "Buffer for complain() is too small");
  strcpy(buf, prefix);

  err = strcat_s(buf, sizeof(buf), msg);
  if (err != 0) {
    /* エラー処理 */
  }

  err = strcat_s(buf, sizeof(buf), suffix);
  if (err != 0) {
    /* エラー処理 */
  }
  fputs(buf, stderr);
}

リスク評価

C99 のセクション 7.21 やその他で定義されている文字列処理関数を使うと
深刻かつ悪用可能な脆弱性につながる。
ありがちなプログラミングエラーを引き起こしやすい。
TR 24731 関数を適切に使用することで、これらの問題の大部分を排除できる。

自動検出

LDRA tool suite V 7.6.0 はこのレコメンデーションの違反を検出できる。

参考情報

• [ISO/IEC 9899:1999] Section 7.21, "String handling <string.h>"
• [ISO/IEC PDTR 24772] "TRJ Use of Libraries"
• [ISO/IEC TR 24731-1:2007]
• [Seacord 05a] Chapter 2, "Strings"
• [Seacord 05b]

ここで、signed修飾子とunsigned修飾子の意味を考えましょう。
C言語の変数は型に規定された一定の数までしか表現できません。

この中で、short、int、longの3つの型は既にsigned修飾されています。
signed修飾とは「この変数は符号付きですよ」という修飾です。
逆にunsigned修飾を行うと「この変数は符号なしですよ」という修飾になります。
そうすると、範囲は次のようになります。