C++
キーワード

前書き

構文

• asm（ 文字列リテラル ）;
• noexcept（ 式 ）//意味1
• noexcept（ 定数式 ）//意味2
• noexcept //意味2
• 単項式のサイズ
• sizeof（ type-id ）
• sizeof ...（ 識別子 ）//以降C ++ 11
• typename ネストされた名前指定子の 識別子 //意味1
• typename ネストされた名前指定子テンプレート（ opt ） simple-template-id //意味1
• 型名識別子 （ opt ）//意味2
• typename ... 識別子 （ opt ）//意味2; C ++ 11以降
• タイプ名 識別子 （ opt ）= タイプID //意味2
• テンプレート< template-parameter-list >型名...（ opt ） 識別子 （ opt ）//意味3
• テンプレート< template-parameter-list >型名識別子 （ opt ）= id-expression //意味3

備考

asm

asmキーワードは、単一のオペランドをとります。これは文字列リテラルでなければなりません。これは実装定義の意味を持ちますが、通常は実装のアセンブラに渡され、アセンブラの出力は変換ユニットに組み込まれます。

asm文は式ではなく定義であるため、ブロックスコープまたはネームスペーススコープ（グローバルスコープを含む）のいずれかに現れることがあります。しかし、インラインアセンブリはC ++言語の規則によって制約を受けることができないので、 asmはconstexpr関数の中に現れないことがあります。

例：

[[noreturn]] void halt_system() {
    asm("hlt");
}

明白な

1. 単一引数のコンストラクタに適用すると、そのコンストラクタが暗黙的な変換を実行するのを防ぐことができます。

   class MyVector {
     public:
       explicit MyVector(uint64_t size);
   };
   MyVector v1(100);  // ok
   uint64_t len1 = 100;
   MyVector v2{len1}; // ok, len1 is uint64_t
   int len2 = 100;
   MyVector v3{len2}; // ill-formed, implicit conversion from int to uint64_t
   

   C ++ 11ではイニシャライザリストが導入されているので、C ++ 11以降では、単一引数の場合と同じ意味で、任意の数の引数を持つコンストラクタにexplicitに適用できます。

   struct S {
       explicit S(int x, int y);
   };
   S f() {
       return {12, 34};  // ill-formed
       return S{12, 34}; // ok
   }
   

noexcept

void g1() {}
void g2() noexcept {}
void (*p1)() noexcept = &g1; // ill-formed, since g1 is not noexcept
void (*p2)() noexcept = &g2; // ok; types match
void (*p3)() = &g1;          // ok; types match
void (*p4)() = &g2;          // ok; implicit conversion

タイプ名

1. 名前の後に修飾名がある場合、 typenameはその名前が型の名前であることを示します。これは、ネストされた名前指定子が現在のインスタンス化以外の依存型である場合、特にテンプレートで必要となることがよくあります。この例では、 std::decay<T>テンプレートパラメータに依存Tネストされた型の名前にするためにので、 type 、我々が全体の修飾名の前に付ける必要がありtypename 。より多くのdeatils については、「テンプレート」と「typename」のキーワードをどこに、なぜ入れなければならないのかを参照してください。

   template <class T>
   auto decay_copy(T&& r) -> typename std::decay<T>::type;
   

2. テンプレートの宣言に型パラメータを導入します。この文脈では、 classと互換性があります。

   template <typename T>
   const T& min(const T& x, const T& y) {
       return b < a ? b : a;
   } 
   

のサイズ

そのオペランドのバイト数を示す単項演算子。式または型のいずれかです。オペランドが式の場合、評価されません。サイズは、 std::size_t型の定数式です。

オペランドが型の場合は、括弧で囲む必要があります。

• 関数型にsizeofを適用することは不正です。
• voidを含む不完全な型にsizeofを適用することは不正です。
• sizeofが参照型T& or T&&に適用される場合、 sizeof(T)と等価です。
• sizeofクラス型に適用すると、中間または末尾のパディングバイトを含む、その型の完全なオブジェクトのバイト数が得られます。したがって、 sizeof式の値は決して0になりません。詳細については、オブジェクト型のレイアウトを参照してください。
• char 、 signed char 、およびunsigned char型のサイズは1です。逆に、1バイトはcharオブジェクトを格納するために必要なメモリ量として定義されます。一部のシステムでは8ビットよりも長いcharオブジェクトがあるため、必ずしも8ビットを意味するわけではありません。

exprが式の場合、 sizeof( expr )はsizeof(T)と等価です。ここで、 Tはexprの型です。

int a[100];
std::cout << "The number of bytes in `a` is: " << sizeof a;
memset(a, 0, sizeof a); // zeroes out the array

template <class... T>
void f(T&&...) {
    std::cout << "f was called with " << sizeof...(T) << " arguments\n";
}

異なるキーワード

void C ++

1. 関数の戻り値の型として使用される場合、voidキーワードは、関数が値を返さないことを指定します。関数のパラメータリストに使用すると、voidはその関数がパラメータを取らないことを指定します。ポインターの宣言で使用される場合、voidはポインターが「ユニバーサル」であることを指定します。

2. ポインタの型がvoid *の場合、ポインタはconstまたはvolatileキーワードで宣言されていない変数を指すことができます。ボイドポインタは、別の型にキャストされていない限り参照解除できません。 voidポインターは、他のタイプのデータポインターに変換することができます。

3. voidポインターは関数を指し示すことができますが、C ++のクラスメンバーは指すことができません。

   void vobject;   // C2182  
   void *pv;   // okay  
   int *pint; int i;  
   int main() {  
   pv = &i;  
      // Cast optional in C required in C++  
   pint = (int *)pv;  
   

揮発性C ++

1. ハードウェアによってプログラム内でオブジェクトを変更できることを宣言するために使用できる型修飾子。

   volatile declarator ;
   

仮想C ++

1. virtualキーワードは、仮想関数または仮想基本クラスを宣言します。

   virtual [type-specifiers] member-function-declarator  
   virtual [access-specifier] base-class-name 
   

パラメーター

1. type-specifiers仮想メンバー関数の戻り値の型を指定します。

2. member-function-declaratorメンバ関数を宣言します。

3. access-specifier基本クラスpublic、protectedまたはprivateへのアクセスレベルを定義します。仮想キーワードの前後に表示できます。

4. base-class-name以前に宣言されたクラスの型を識別します。

このポインタ

1. このポインタは、クラス、構造体、または共用体型の非静的メンバー関数内でのみアクセス可能なポインタです。これは、メンバー関数が呼び出されるオブジェクトを指します。静的メンバー関数にはこのポインタはありません。

   this->member-identifier  
   

オブジェクトのこのポインタはオブジェクト自体の一部ではありません。オブジェクトのsizeof文の結果には反映されません。代わりに、非静的メンバ関数がオブジェクトに対して呼び出されると、オブジェクトのアドレスは関数の隠し引数としてコンパイラによって渡されます。たとえば、次の関数呼び出し：

myDate.setMonth( 3 );  

can be interpreted this way:


setMonth( &myDate, 3 );  

The object's address is available from within the member function as the this pointer. Most uses of this are implicit. It is legal, though unnecessary, to explicitly use this when referring to members of the class. For example:


void Date::setMonth( int mn )  
{  
   month = mn;            // These three statements  
   this->month = mn;      // are equivalent  
   (*this).month = mn;  
}  

The expression *this is commonly used to return the current object from a member function:


return *this;  

The this pointer is also used to guard against self-reference:


if (&Object != this) {  
// do not execute in cases of self-reference 

try、throw、catchステートメント（C ++）

1. C ++で例外処理を実装するには、try、throw、catch式を使用します。
2. まず、tryブロックを使用して、例外をスローする可能性のある1つ以上のステートメントを囲みます。
3. スロー式は、tryブロック内で例外条件（しばしばエラー）が発生したことを通知します。任意のタイプのオブジェクトをスロー式のオペランドとして使用できます。通常、このオブジェクトは、エラーに関する情報の通信に使用されます。ほとんどの場合、std :: exceptionクラス、または標準ライブラリで定義されている派生クラスのいずれかを使用することをお勧めします。そのうちの1つが適切でない場合は、std :: exceptionから独自の例外クラスを派生させることをお勧めします。
4. スローされる可能性のある例外を処理するには、tryブロックの直後に1つ以上のcatchブロックを実装します。それぞれのcatchブロックは、処理できる例外のタイプを指定します。

    MyData md;  
try {  
   // Code that could throw an exception  
   md = GetNetworkResource();  
}  
catch (const networkIOException& e) {  
   // Code that executes when an exception of type  
   // networkIOException is thrown in the try block  
   // ...  
   // Log error message in the exception object  
   cerr << e.what();  
}  
catch (const myDataFormatException& e) {  
   // Code that handles another exception type  
   // ...  
   cerr << e.what();  
}  
  
// The following syntax shows a throw expression  
MyData GetNetworkResource()  
{  
   // ...  
   if (IOSuccess == false)  
      throw networkIOException("Unable to connect");  
   // ...  
   if (readError)  
      throw myDataFormatException("Format error");   
   // ...  
}

try節の後のコードは、コードの保護されたセクションです。 throwのスロー - つまりraise - 例外です。 catch節の後のコードブロックは例外ハンドラです。これは、throw式とcatch式の型が互換性がある場合にスローされる例外をキャッチするハンドラです。

    try {  
   throw CSomeOtherException();  
}  
catch(...) {  
   // Catch all exceptions – dangerous!!!  
   // Respond (perhaps only partially) to the exception, then  
   // re-throw to pass the exception to some other handler  
   // ...  
   throw;  
}

友人（C ++）

1. 場合によっては、クラスのメンバーでない関数または別のクラスのすべてのメンバーにメンバーレベルのアクセス権を与える方が便利です。クラスの実装者だけが、その友達が誰であるかを宣言することができます。関数またはクラスは、自分自身をクラスのフレンドとして宣言することはできません。クラス定義では、friendキーワードと非メンバー関数または他のクラスの名前を使用して、クラスのプライベートメンバーおよび保護されたメンバーへのアクセスを許可します。テンプレート定義では、タイプパラメータをフレンドとして宣言できます。

2. 以前に宣言されていないフレンド関数を宣言すると、その関数は囲む非クラススコープにエクスポートされます。

   class friend F  
   friend F;
   class ForwardDeclared;// Class name is known.  
   class HasFriends  
   {  
      friend int ForwardDeclared::IsAFriend();// C2039 error expected  
   };  
   

友人機能

1. フレンド関数は、クラスのメンバーではなく、クラスのプライベートメンバーおよび保護されたメンバーにアクセスできる関数です。フレンド関数はクラスメンバーとはみなされません。特殊なアクセス特権が与えられている通常の外部関数です。

2. フレンドはクラスのスコープにはなく、別のクラスのメンバーでない限りメンバー選択演算子（。と - >）を使用して呼び出されません。

3. friend関数は、アクセスを許可しているクラスによって宣言されています。フレンド宣言は、クラス宣言のどこにでも配置できます。アクセス制御キーワードの影響を受けません。

   #include <iostream>  
   
   using namespace std;  
   class Point  
   {  
       friend void ChangePrivate( Point & );  
   public:  
       Point( void ) : m_i(0) {}  
       void PrintPrivate( void ){cout << m_i << endl; }  
   
   private:  
   int m_i;  
   };  
   
   void ChangePrivate ( Point &i ) { i.m_i++; }  
   
   int main()  
   {  
      Point sPoint;  
      sPoint.PrintPrivate();  
      ChangePrivate(sPoint);  
      sPoint.PrintPrivate();  
       // Output: 0  
              1  
   }  
   

友達としてのクラスメンバー

class B;  

class A {  
public:  
   int Func1( B& b );  

private:  
   int Func2( B& b );  
};  

class B {  
private:  
int _b;  

   // A::Func1 is a friend function to class B  
   // so A::Func1 has access to all members of B  
   friend int A::Func1( B& );  
};  

int A::Func1( B& b ) { return b._b; }   // OK  
int A::Func2( B& b ) { return b._b; }   // C2248