emmtrix Wiki - User contributions [en]

Demystifying C++ - Classes/en

2023-10-30T10:33:11Z

FuzzyBot: Updating to match new version of source page

<languages/>
Classes are a cornerstone of C++ programming, embodying the object-oriented paradigm, which is essential for structuring modern, complex software applications. In C++, classes encapsulate data and behavior through attributes and methods. In contrast, Assembler and C primarily rely on data structures and functions.

===Methods===
Just as the C++ compiler does, the transpiler translates classes into C structures and functions. The methods of the class are turned into functions that take a "this" pointer to the structure representing the class. When accessing attributes, the this-pointer is used automatically, and when calling other methods, it is simply passed on.
{| class="wikitable"
!Methods
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

void C1_onChangeAttr(struct C1* this);

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

===Inheritance===

In C++, inheritance is a central principle that allows classes to inherit attributes and methods from base classes. However, C does not naturally support inheritance. Therefore, the C++ to C transpiler uses special techniques to simulate inheritance relationships by embedding each base class as its own field in the derived structure.

A crucial aspect of inheritance is the casting between base classes (Base) and derived classes (Derived):

*'''Derived-to-Base Casts''': In assembler, such a cast corresponds to an addition with a constant value. These are relatively simple to implement in C by accessing the respective field in the derived structure. This happens implicitly in C++ in many places, such as when calling base class methods or accessing attributes.
*'''Static Base-to-Derived Casts''': In assembler, such a cast corresponds to a subtraction with a constant value. This is more complex in C and requires some C casting.
*'''Dynamic Base-to-Derived Casts''': These are produced with the <code>dynamic_cast</code> keyword and are more complex in implementation since they require type checking at runtime. Dynamic casts will be discussed in the chapter on virtual classes.


{| class="wikitable"
!Representation of Base Classes
|<pre>
class Derived : public Base1, public Base2 {
...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;

...
};
</pre>
|-
!Derived-to-Base Cast
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!Static Base-To-Derived Cast
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

===Constructors and Destructors===
Constructors and destructors play a pivotal role in C++ programming as they manage automatic initialization and cleanup processes for objects. Constructors are special class methods that are automatically invoked when an object is created. They're often used to define initial values for object attributes and perform other initialization tasks. Destructors are the opposite of constructors; they're invoked when an object is destroyed and are ideal for cleanup tasks like releasing memory and other resources.

In C, there's no direct counterpart for constructors and destructors. Instead, they are replaced by regular functions that are called upon object creation or destruction. For completeness, it should be mentioned that for the Itanium ABI, at least two constructor functions (<code>ctor_complete</code>, <code>ctor_base</code>) and destructor functions (<code>dtor_complete</code>, <code>dtor_base</code>, <code>dtor_delete</code>) are generated. The complete variants are typically used, base variants are required for base classes in the constructor/destructor, and <code>dtor_delete</code> is used when applying delete to a class with a virtual destructor.


{| class="wikitable"
|-
!Constructors
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}

~C1() {
// Cleanup code
}
};
</pre>
|<pre>
struct C1 {
// Attributes
};

void C1_ctor_complete(struct C1* this) {
// Initialization code
}

void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!Stack Variables
|<pre>
{
C1 obj;

...
}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);

...

C1_dtor_complete(&obj);
}
</pre>
|}

[[Category:Demystifying C++|Classes]]

Demystifying C++ - Classes/ja

2023-10-30T10:33:10Z

FuzzyBot: Updating to match new version of source page

<languages/>
クラスはC++プログラミングの基石であり、現代の複雑なソフトウェアアプリケーションの構造化に不可欠なオブジェクト指向パラダイムを体現しています。C++では、クラスは属性とメソッドを通じてデータと振る舞いをカプセル化します。対照的に、アセンブラやCは主にデータ構造と関数に依存しています。

===メソッド===
C++コンパイラと同様に、トランスパイラはクラスをCの構造体と関数に変換します。クラスのメソッドは、クラスを表す構造体への"this"ポインタを取る関数に変換されます。属性にアクセスする際には、thisポインタが自動的に使用され、他のメソッドを呼び出す際には、それが単に渡されます。
{| class="wikitable"
!メソッド
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

void C1_onChangeAttr(struct C1* this);

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

===継承===

C++では、継承はクラスが基底クラスから属性やメソッドを継承することを可能にする中心的な原則です。しかし、Cは自然に継承をサポートしていません。そのため、C++からCへのトランスパイラは、派生構造体の各基底クラスをその独自のフィールドとして埋め込むことで、継承関係をシミュレートする特別な技術を使用します。

継承の重要な側面は、基底クラス（Base）と派生クラス（Derived）間のキャスティングです：

*'''派生クラスから基底クラスへのキャスト''': アセンブラでは、このようなキャストは定数値の加算に対応します。これは、派生構造体の該当するフィールドにアクセスすることでCで比較的簡単に実装できます。これは、基底クラスのメソッドを呼び出す場合や属性にアクセスする場合など、C++の多くの場所で暗黙的に発生します。
*'''静的な基底クラスから派生クラスへのキャスト''': アセンブラでは、このようなキャストは定数値の減算に対応します。これはCでより複雑であり、いくつかのCキャスティングが必要です。
*'''動的な基底クラスから派生クラスへのキャスト''': これらは<code>dynamic_cast</code>キーワードで生成され、実装がより複雑です。これはランタイム時の型チェックが必要です。動的キャストについては、仮想クラスに関する章で議論されます。


{| class="wikitable"
!基底クラスの表現
|<pre>
class Derived : public Base1, public Base2 {
...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;

...
};
</pre>
|-
!派生クラスから基底クラスへのキャスト
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!静的な基底クラスから派生クラスへのキャスト
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

===コンストラクタとデストラクタ===
コンストラクタとデストラクタは、オブジェクトの自動初期化とクリーンアッププロセスを管理するため、C++プログラミングにおいて中心的な役割を果たします。コンストラクタはオブジェクトが作成されるときに自動的に呼び出される特別なクラスメソッドです。オブジェクト属性の初期値を定義したり、他の初期化タスクを実行するためによく使用されます。デストラクタはコンストラクタの反対であり、オブジェクトが破棄されるときに呼び出され、メモリや他のリソースを解放するようなクリーンアップタスクに最適です。

Cでは、コンストラクタとデストラクタの直接的な対応物はありません。代わりに、オブジェクトの作成や破棄時に呼び出される通常の関数に置き換えられます。完全性のために、Itanium ABIには、少なくとも2つのコンストラクタ関数（<code>ctor_complete</code>、<code>ctor_base</code>）およびデストラクタ関数（<code>dtor_complete</code>、<code>dtor_base</code>、<code>dtor_delete</code>）が生成されることを述べておくべきです。completeバリアントは通常使用され、baseバリアントはコンストラクタ/デストラクタ内の基底クラスに必要であり、<code>dtor_delete</code>は仮想デストラクタを持つクラスにdeleteを適用するときに使用されます。


{| class="wikitable"
|-
!コンストラクタ
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}

~C1() {
// Cleanup code
}
};
</pre>
|<pre>
struct C1 {
// Attributes
};

void C1_ctor_complete(struct C1* this) {
// Initialization code
}

void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!スタック変数
|<pre>
{
C1 obj;

...
}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);

...

C1_dtor_complete(&obj);
}
</pre>
|}

[[Category:Demystifying C++|Classes]]

Category:Demystifying C++/en

2023-10-30T10:24:01Z

FuzzyBot: Updating to match new version of source page

[[Category:C++ to C Compiler]]

Demystifying C++ - Classes/en

2023-10-30T10:17:54Z

FuzzyBot: Updating to match new version of source page

<languages/>
Classes are a cornerstone of C++ programming, embodying the object-oriented paradigm, which is essential for structuring modern, complex software applications. In C++, classes encapsulate data and behavior through attributes and methods. In contrast, Assembler and C primarily rely on data structures and functions.

===Methods===
Just as the C++ compiler does, the transpiler translates classes into C structures and functions. The methods of the class are turned into functions that take a "this" pointer to the structure representing the class. When accessing attributes, the this-pointer is used automatically, and when calling other methods, it is simply passed on.
{| class="wikitable"
!Methods
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

void C1_onChangeAttr(struct C1* this);

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

===Inheritance===

In C++, inheritance is a central principle that allows classes to inherit attributes and methods from base classes. However, C does not naturally support inheritance. Therefore, the C++ to C transpiler uses special techniques to simulate inheritance relationships by embedding each base class as its own field in the derived structure.

A crucial aspect of inheritance is the casting between base classes (Base) and derived classes (Derived):

*'''Derived-to-Base Casts''': In assembler, such a cast corresponds to an addition with a constant value. These are relatively simple to implement in C by accessing the respective field in the derived structure. This happens implicitly in C++ in many places, such as when calling base class methods or accessing attributes.
*'''Static Base-to-Derived Casts''': In assembler, such a cast corresponds to a subtraction with a constant value. This is more complex in C and requires some C casting.
*'''Dynamic Base-to-Derived Casts''': These are produced with the <code>dynamic_cast</code> keyword and are more complex in implementation since they require type checking at runtime. Dynamic casts will be discussed in the chapter on virtual classes.


{| class="wikitable"
!Representation of Base Classes
|<pre>
class Derived : public Base1, public Base2 {


...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;

...
};
</pre>
|-
!Derived-to-Base Cast
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!Static Base-To-Derived Cast
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

===Constructors and Destructors===
Constructors and destructors play a pivotal role in C++ programming as they manage automatic initialization and cleanup processes for objects. Constructors are special class methods that are automatically invoked when an object is created. They're often used to define initial values for object attributes and perform other initialization tasks. Destructors are the opposite of constructors; they're invoked when an object is destroyed and are ideal for cleanup tasks like releasing memory and other resources.

In C, there's no direct counterpart for constructors and destructors. Instead, they are replaced by regular functions that are called upon object creation or destruction. For completeness, it should be mentioned that for the Itanium ABI, at least two constructor functions (<code>ctor_complete</code>, <code>ctor_base</code>) and destructor functions (<code>dtor_complete</code>, <code>dtor_base</code>, <code>dtor_delete</code>) are generated. The complete variants are typically used, base variants are required for base classes in the constructor/destructor, and <code>dtor_delete</code> is used when applying delete to a class with a virtual destructor.


{| class="wikitable"
|-
!Constructors
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}

~C1() {
// Cleanup code
}
};


</pre>
|<pre>
struct C1 {
// Attributes
};

void C1_ctor_complete(struct C1* this) {
// Initialization code
}

void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!Stack Variables
|<pre>
{
C1 obj;

...


}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);

...

C1_dtor_complete(&obj);
}
</pre>
|}

[[Category:Demystifying C++|Classes]]

Translations:Demystifying C++ - Classes/29/en

2023-10-30T10:17:52Z

FuzzyBot: Importing a new version from external source

Stack Variables

Translations:Demystifying C++ - Classes/28/en

2023-10-30T10:17:52Z

FuzzyBot: Importing a new version from external source

Constructors

Translations:Demystifying C++ - Classes/27/en

2023-10-30T10:17:52Z

FuzzyBot: Importing a new version from external source

Static Base-To-Derived Cast

Translations:Demystifying C++ - Classes/26/en

2023-10-30T10:17:52Z

FuzzyBot: Importing a new version from external source

Derived-to-Base Cast

Translations:Demystifying C++ - Classes/25/en

2023-10-30T10:17:52Z

FuzzyBot: Importing a new version from external source

Representation of Base Classes

Demystifying C++ - Classes/ja

2023-10-30T10:08:42Z

FuzzyBot: Updating to match new version of source page

<languages/>
クラスはC++プログラミングの基石であり、現代の複雑なソフトウェアアプリケーションの構造化に不可欠なオブジェクト指向パラダイムを体現しています。C++では、クラスは属性とメソッドを通じてデータと振る舞いをカプセル化します。対照的に、アセンブラやCは主にデータ構造と関数に依存しています。

<div class="mw-translate-fuzzy">
===メソッド===
C++コンパイラと同様に、トランスパイラはクラスをCの構造体と関数に変換します。クラスのメソッドは、クラスを表す構造体への"this"ポインタを取る関数に変換されます。属性にアクセスする際には、thisポインタが自動的に使用され、他のメソッドを呼び出す際には、それが単に渡されます。
{| class="wikitable"
!メソッド
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();
</div>
{| class="wikitable"
!Methods
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

void C1_onChangeAttr(struct C1* this);

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

===Inheritance===

In C++, inheritance is a central principle that allows classes to inherit attributes and methods from base classes. However, C does not naturally support inheritance. Therefore, the C++ to C transpiler uses special techniques to simulate inheritance relationships by embedding each base class as its own field in the derived structure.

A crucial aspect of inheritance is the casting between base classes (Base) and derived classes (Derived):

*'''Derived-to-Base Casts''': In assembler, such a cast corresponds to an addition with a constant value. These are relatively simple to implement in C by accessing the respective field in the derived structure. This happens implicitly in C++ in many places, such as when calling base class methods or accessing attributes.
*'''Static Base-to-Derived Casts''': In assembler, such a cast corresponds to a subtraction with a constant value. This is more complex in C and requires some C casting.
*'''Dynamic Base-to-Derived Casts''': These are produced with the <code>dynamic_cast</code> keyword and are more complex in implementation since they require type checking at runtime. Dynamic casts will be discussed in the chapter on virtual classes.


{| class="wikitable"
!Representation of Base Classes
|<pre>
class Derived : public Base1, public Base2 {


...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;


...
};
</pre>
|-
!Derived-to-Base Cast
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!Static Base-To-Derived Cast
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

===Constructors and Destructors===
Constructors and destructors play a pivotal role in C++ programming as they manage automatic initialization and cleanup processes for objects. Constructors are special class methods that are automatically invoked when an object is created. They're often used to define initial values for object attributes and perform other initialization tasks. Destructors are the opposite of constructors; they're invoked when an object is destroyed and are ideal for cleanup tasks like releasing memory and other resources.

In C, there's no direct counterpart for constructors and destructors. Instead, they are replaced by regular functions that are called upon object creation or destruction. For completeness, it should be mentioned that for the Itanium ABI, at least two constructor functions (<code>ctor_complete</code>, <code>ctor_base</code>) and destructor functions (<code>dtor_complete</code>, <code>dtor_base</code>, <code>dtor_delete</code>) are generated. The complete variants are typically used, base variants are required for base classes in the constructor/destructor, and <code>dtor_delete</code> is used when applying delete to a class with a virtual destructor.


{| class="wikitable"
|-
!Constructors
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}


~C1() {
// Cleanup code
}
};


</pre>
|<pre>
struct C1 {
// Attributes
};


void C1_ctor_complete(struct C1* this) {
// Initialization code
}


void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!Stack Variables
|<pre>
{
C1 obj;


...


}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);


...


C1_dtor_complete(&obj);
}
</pre>
|}

[[Category:Demystifying C++|Classes]]

Demystifying C++ - Classes/en

2023-10-30T10:08:42Z

FuzzyBot: Updating to match new version of source page

<languages/>
Classes are a cornerstone of C++ programming, embodying the object-oriented paradigm, which is essential for structuring modern, complex software applications. In C++, classes encapsulate data and behavior through attributes and methods. In contrast, Assembler and C primarily rely on data structures and functions.

===Methods===
Just as the C++ compiler does, the transpiler translates classes into C structures and functions. The methods of the class are turned into functions that take a "this" pointer to the structure representing the class. When accessing attributes, the this-pointer is used automatically, and when calling other methods, it is simply passed on.
{| class="wikitable"
!Methods
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

void C1_onChangeAttr(struct C1* this);

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

===Inheritance===

In C++, inheritance is a central principle that allows classes to inherit attributes and methods from base classes. However, C does not naturally support inheritance. Therefore, the C++ to C transpiler uses special techniques to simulate inheritance relationships by embedding each base class as its own field in the derived structure.

A crucial aspect of inheritance is the casting between base classes (Base) and derived classes (Derived):

*'''Derived-to-Base Casts''': In assembler, such a cast corresponds to an addition with a constant value. These are relatively simple to implement in C by accessing the respective field in the derived structure. This happens implicitly in C++ in many places, such as when calling base class methods or accessing attributes.
*'''Static Base-to-Derived Casts''': In assembler, such a cast corresponds to a subtraction with a constant value. This is more complex in C and requires some C casting.
*'''Dynamic Base-to-Derived Casts''': These are produced with the <code>dynamic_cast</code> keyword and are more complex in implementation since they require type checking at runtime. Dynamic casts will be discussed in the chapter on virtual classes.


{| class="wikitable"
!Representation of Base Classes
|<pre>
class Derived : public Base1, public Base2 {


...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;


...
};
</pre>
|-
!Derived-to-Base Cast
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!Static Base-To-Derived Cast
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

===Constructors and Destructors===
Constructors and destructors play a pivotal role in C++ programming as they manage automatic initialization and cleanup processes for objects. Constructors are special class methods that are automatically invoked when an object is created. They're often used to define initial values for object attributes and perform other initialization tasks. Destructors are the opposite of constructors; they're invoked when an object is destroyed and are ideal for cleanup tasks like releasing memory and other resources.

In C, there's no direct counterpart for constructors and destructors. Instead, they are replaced by regular functions that are called upon object creation or destruction. For completeness, it should be mentioned that for the Itanium ABI, at least two constructor functions (<code>ctor_complete</code>, <code>ctor_base</code>) and destructor functions (<code>dtor_complete</code>, <code>dtor_base</code>, <code>dtor_delete</code>) are generated. The complete variants are typically used, base variants are required for base classes in the constructor/destructor, and <code>dtor_delete</code> is used when applying delete to a class with a virtual destructor.


{| class="wikitable"
|-
!Constructors
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}


~C1() {
// Cleanup code
}
};


</pre>
|<pre>
struct C1 {
// Attributes
};


void C1_ctor_complete(struct C1* this) {
// Initialization code
}


void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!Stack Variables
|<pre>
{
C1 obj;


...


}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);


...


C1_dtor_complete(&obj);
}
</pre>
|}

[[Category:Demystifying C++|Classes]]

Translations:Demystifying C++ - Classes/24/en

2023-10-30T10:08:41Z

FuzzyBot: Importing a new version from external source

Methods

Translations:Demystifying C++ - Classes/2/en

2023-10-30T10:08:41Z

FuzzyBot: Importing a new version from external source

===Methods===
Just as the C++ compiler does, the transpiler translates classes into C structures and functions. The methods of the class are turned into functions that take a "this" pointer to the structure representing the class. When accessing attributes, the this-pointer is used automatically, and when calling other methods, it is simply passed on.

Demystifying C++ - Classes/en

2023-10-30T10:02:35Z

FuzzyBot: Updating to match new version of source page

<languages/>
Classes are a cornerstone of C++ programming, embodying the object-oriented paradigm, which is essential for structuring modern, complex software applications. In C++, classes encapsulate data and behavior through attributes and methods. In contrast, Assembler and C primarily rely on data structures and functions.

===Methods===
Just as the C++ compiler does, the transpiler translates classes into C structures and functions. The methods of the class are turned into functions that take a "this" pointer to the structure representing the class. When accessing attributes, the this-pointer is used automatically, and when calling other methods, it is simply passed on.
{| class="wikitable"
!Methods
|<pre>
class C1 {
int attr;
public:
void onChangeAttr();

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

void C1_onChangeAttr(struct C1* this);

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

===Inheritance===

In C++, inheritance is a central principle that allows classes to inherit attributes and methods from base classes. However, C does not naturally support inheritance. Therefore, the C++ to C transpiler uses special techniques to simulate inheritance relationships by embedding each base class as its own field in the derived structure.

A crucial aspect of inheritance is the casting between base classes (Base) and derived classes (Derived):

*'''Derived-to-Base Casts''': In assembler, such a cast corresponds to an addition with a constant value. These are relatively simple to implement in C by accessing the respective field in the derived structure. This happens implicitly in C++ in many places, such as when calling base class methods or accessing attributes.
*'''Static Base-to-Derived Casts''': In assembler, such a cast corresponds to a subtraction with a constant value. This is more complex in C and requires some C casting.
*'''Dynamic Base-to-Derived Casts''': These are produced with the <code>dynamic_cast</code> keyword and are more complex in implementation since they require type checking at runtime. Dynamic casts will be discussed in the chapter on virtual classes.

{| class="wikitable"
!Representation of Base Classes
|<pre>
class Derived : public Base1, public Base2 {

...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;

...
};
</pre>
|-
!Derived-to-Base Cast
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!Static Base-To-Derived Cast
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

===Constructors and Destructors===
Constructors and destructors play a pivotal role in C++ programming as they manage automatic initialization and cleanup processes for objects. Constructors are special class methods that are automatically invoked when an object is created. They're often used to define initial values for object attributes and perform other initialization tasks. Destructors are the opposite of constructors; they're invoked when an object is destroyed and are ideal for cleanup tasks like releasing memory and other resources.

In C, there's no direct counterpart for constructors and destructors. Instead, they are replaced by regular functions that are called upon object creation or destruction. For completeness, it should be mentioned that for the Itanium ABI, at least two constructor functions (<code>ctor_complete</code>, <code>ctor_base</code>) and destructor functions (<code>dtor_complete</code>, <code>dtor_base</code>, <code>dtor_delete</code>) are generated. The complete variants are typically used, base variants are required for base classes in the constructor/destructor, and <code>dtor_delete</code> is used when applying delete to a class with a virtual destructor.

{| class="wikitable"
|-
!Constructors
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}

~C1() {
// Cleanup code
}
};

</pre>
|<pre>
struct C1 {
// Attributes
};

void C1_ctor_complete(struct C1* this) {
// Initialization code
}

void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!Stack Variables
|<pre>
{
C1 obj;

...

}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);

...

C1_dtor_complete(&obj);
}
</pre>
|}

[[Category:Demystifying C++|Classes]]

Translations:Demystifying C++ - Classes/23/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

C1_dtor_complete(&obj);
}
</pre>
|}

Translations:Demystifying C++ - Classes/22/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

...

Translations:Demystifying C++ - Classes/21/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

}
</pre>
|<pre>
{
struct C1 obj;
C1_ctor_complete(&obj);

Translations:Demystifying C++ - Classes/20/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

...

Translations:Demystifying C++ - Classes/19/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

void C1_dtor_complete(struct C1* this) {
// Cleanup code
}
</pre>
|-
!Stack Variables
|<pre>
{
C1 obj;

Translations:Demystifying C++ - Classes/18/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

void C1_ctor_complete(struct C1* this) {
// Initialization code
}

Translations:Demystifying C++ - Classes/17/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

</pre>
|<pre>
struct C1 {
// Attributes
};

Translations:Demystifying C++ - Classes/16/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

~C1() {
// Cleanup code
}
};

Translations:Demystifying C++ - Classes/15/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

{| class="wikitable"
|-
!Constructors
|<pre>
class C1 {
// Attributes
public:
C1() {
// Initialization code
}

Translations:Demystifying C++ - Classes/14/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

In C, there's no direct counterpart for constructors and destructors. Instead, they are replaced by regular functions that are called upon object creation or destruction. For completeness, it should be mentioned that for the Itanium ABI, at least two constructor functions (<code>ctor_complete</code>, <code>ctor_base</code>) and destructor functions (<code>dtor_complete</code>, <code>dtor_base</code>, <code>dtor_delete</code>) are generated. The complete variants are typically used, base variants are required for base classes in the constructor/destructor, and <code>dtor_delete</code> is used when applying delete to a class with a virtual destructor.

Translations:Demystifying C++ - Classes/13/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

===Constructors and Destructors===
Constructors and destructors play a pivotal role in C++ programming as they manage automatic initialization and cleanup processes for objects. Constructors are special class methods that are automatically invoked when an object is created. They're often used to define initial values for object attributes and perform other initialization tasks. Destructors are the opposite of constructors; they're invoked when an object is destroyed and are ideal for cleanup tasks like releasing memory and other resources.

Translations:Demystifying C++ - Classes/12/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

...
};
</pre>
|-
!Derived-to-Base Cast
|<pre>
static_cast<Base2*>(derived)
</pre>
|<pre>
&derived->base2
</pre>
|-
!Static Base-To-Derived Cast
|<pre>
static_cast<Derived*>(base2)
</pre>
|<pre>
(Derived*)((char*)base2 - offsetof(Derived, base2))
</pre>
|}

Translations:Demystifying C++ - Classes/11/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

...
};
</pre>
|<pre>
struct Derived {
struct Base1 base1;
struct Base2 base2;

Translations:Demystifying C++ - Classes/10/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

{| class="wikitable"
!Representation of Base Classes
|<pre>
class Derived : public Base1, public Base2 {

Translations:Demystifying C++ - Classes/9/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

*'''Derived-to-Base Casts''': In assembler, such a cast corresponds to an addition with a constant value. These are relatively simple to implement in C by accessing the respective field in the derived structure. This happens implicitly in C++ in many places, such as when calling base class methods or accessing attributes.
*'''Static Base-to-Derived Casts''': In assembler, such a cast corresponds to a subtraction with a constant value. This is more complex in C and requires some C casting.
*'''Dynamic Base-to-Derived Casts''': These are produced with the <code>dynamic_cast</code> keyword and are more complex in implementation since they require type checking at runtime. Dynamic casts will be discussed in the chapter on virtual classes.

Translations:Demystifying C++ - Classes/8/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

A crucial aspect of inheritance is the casting between base classes (Base) and derived classes (Derived):

Translations:Demystifying C++ - Classes/7/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

In C++, inheritance is a central principle that allows classes to inherit attributes and methods from base classes. However, C does not naturally support inheritance. Therefore, the C++ to C transpiler uses special techniques to simulate inheritance relationships by embedding each base class as its own field in the derived structure.

Translations:Demystifying C++ - Classes/6/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

===Inheritance===

Translations:Demystifying C++ - Classes/5/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

void C1_setAttr(struct C1* this, int v) {
this->attr = v;
C1_onChangeAttr(this);
}
</pre>
|}

Translations:Demystifying C++ - Classes/4/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

void C1_onChangeAttr(struct C1* this);

Translations:Demystifying C++ - Classes/3/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

void setAttr(int v) {
attr = v;
onChangeAttr();
}
};
</pre>
|<pre>
struct C1 {
int attr;
};

Translations:Demystifying C++ - Classes/2/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

Translations:Demystifying C++ - Classes/1/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

Classes are a cornerstone of C++ programming, embodying the object-oriented paradigm, which is essential for structuring modern, complex software applications. In C++, classes encapsulate data and behavior through attributes and methods. In contrast, Assembler and C primarily rely on data structures and functions.

Translations:Demystifying C++ - Classes/Page display title/en

2023-10-30T10:02:33Z

FuzzyBot: Importing a new version from external source

Demystifying C++ - Classes

Demystifying C++/en

2023-10-30T09:59:29Z

FuzzyBot: Updating to match new version of source page

<languages/>
[[File:Demystifying C++ Ghost.png|alt=|thumb|Demystifying C++]]

[[File:Demystifying C++ Ghost.png|alt=|thumb|Demystifying C++]]
In the world of programming, there is a constant evolution and adaptation of languages and tools to meet the ever-growing demands of software development. While C++ is considered one of the most powerful and versatile programming languages, its complexity can often be intimidating and challenging. In this article, we take a look behind the scenes and demystify the sometimes complex C++ constructs through the lens of a C++ to C transpiler. Whether you are an experienced developer or someone just delving into the depths of C++, this article offers fascinating insights into the machinery that drives this powerful language.

==C++ to C Transpiler==
A transpiler, also known as a source-to-source compiler, is a special tool that translates the source code of one programming language into the source code of another programming language. Unlike traditional compilers that translate source code into machine code, transpilers convert code from one high-level language to another.

At emmtrix, a C++ to C transpiler is currently under development [https://www.emmtrix.com/tools/emmtrix-cpp-to-c-compiler]. It is based on the tried-and-true clang frontend, a state-of-the-art compiler frontend that is part of the broader LLVM project. A standout feature is ensuring semantic equivalence between the original C++ code and the generated C code. This means that despite the differences between the two languages, the translated code exhibits the same behavior as the original code.

To ensure semantic equivalence, a comparison tool is used. This tool translates both the original C++ code and the generated C code into the LLVM IR (Intermediate Representation) and compares these two representations. Through this comparison, it can be ensured that the generated code not only produces the same output in test cases but also that semantically identical code is produced on every run (or an error is displayed). This approach is recognized as a method for ensuring error-free operation in both ISO26262 and DO-178C.

The transpiler supports all C++14 language features as well as common GCC/Clang language extensions. Only exceptions are not fully supported because they cannot be replicated in C on a 1-to-1 basis. In addition to the C++ standard, the Itanium C++ ABI [https://itanium-cxx-abi.github.io/cxx-abi/abi.html] is used, which specifies the binary interface (i.e., application binary interface, ABI), for example, how classes with inheritance are implemented.

Within the article, the transpiler is used to demystify C++ because the C output makes the implementation of the C++ constructs by the compiler easily understandable.

==C++ Construct==
* [[Demystifying C++ - Classes|Classes]]
* [[Demystifying C++ - Virtual Classes (Polymorphism)|Virtual classes (polymorphism)]]
* [[Demystifying C++ - New and Delete Operators|New and delete operators]]
* [[Demystifying C++ - Initialization of Global Variables|Initialization of global variables]]
* [[Demystifying C++ - Templates|Templates]]
* [[Demystifying C++ - Cleanup Code|Cleanup code]]
* [[Demystifying C++ - Range-Based for Loops|Range-based for loops]]

== Ideas for Future ==

* Member function pointers
* Array new and delete
* Exceptions

[[Category:Demystifying C++|!Demystifying_C++]]

Demystifying C++/ja

2023-10-30T09:59:29Z

FuzzyBot: Updating to match new version of source page

<languages/>
[[File:Demystifying C++ Ghost.png|alt=|thumb|C++の解明]]

<div class="mw-translate-fuzzy">
プログラミングの世界では、ソフトウェア開発の絶えず増大する要求に応えるための言語やツールの進化と適応が続いています。C++は最も強力で多目的なプログラミング言語の一つとみなされていますが、その複雑さはしばしば威圧的であり、挑戦的です。この記事では、C++からCへのトランスパイラの視点を通して、時折複雑なC++の構造を解明して、舞台裏をのぞき見ます。あなたが経験豊富な開発者であろうと、C++の深淵に初めて足を踏み入れる人であろうと、この記事はこの強力な言語を駆動する仕組みに関する魅力的な洞察を提供します。
</div>

==C++からCへのトランスパイラ==
トランスパイラは、ソースツーソースコンパイラとしても知られています。これは、あるプログラミング言語のソースコードを別のプログラミング言語のソースコードに変換する特別なツールです。ソースコードを機械コードに変換する伝統的なコンパイラとは異なり、トランスパイラは高水準の言語のコードを別の高水準の言語に変換します。

emmtrixでは、C++からCへのトランスパイラが現在開発中です[https://www.emmtrix.com/tools/emmtrix-cpp-to-c-compiler]。これは、広範なLLVMプロジェクトの一部である最先端のコンパイラフロントエンドであるclangフロントエンドに基づいています。顕著な特徴は、元のC++コードと生成されたCコードの間の意味的な同等性を確保することです。これは、2つの言語の違いにもかかわらず、翻訳されたコードが元のコードと同じ振る舞いを示すことを意味します。

意味的な同等性を確保するために、比較ツールが使用されます。このツールは、元のC++コードと生成されたCコードの両方をLLVM IR（中間表現）に変換し、これら2つの表現を比較します。この比較を通じて、生成されたコードがテストケースで同じ出力を生成するだけでなく、毎回の実行で意味的に同一のコードが生成されること（またはエラーが表示されること）が確保されます。このアプローチは、ISO26262およびDO-178Cの両方でエラーのない動作を確保する方法として認識されています。

このトランスパイラは、C++14言語の全ての機能および一般的なGCC/Clang言語拡張をサポートしています。唯一の例外は、Cで1対1の基準で再現できないため、完全にはサポートされていません。C++標準に加えて、Itanium C++ ABI [https://itanium-cxx-abi.github.io/cxx-abi/abi.html]が使用されます。これは、例えば継承を持つクラスがどのように実装されるかなど、バイナリインターフェース（すなわち、アプリケーションバイナリインターフェース、ABI）を指定します。

この記事の中で、トランスパイラはC++を解明するために使用されています。なぜなら、Cの出力は、コンパイラによるC++の構造の実装を容易に理解できるようにしているからです。

==C++の構造==
* [[Demystifying C++ - Classes|クラス]]
* [[Demystifying C++ - Virtual Classes (Polymorphism)|仮想クラス (ポリモーフィズム)]]
* [[Demystifying C++ - New and Delete Operators|Newおよびdelete演算子]]
* [[Demystifying C++ - Initialization of Global Variables|グローバル変数の初期化]]
* [[Demystifying C++ - Templates|テンプレート]]
* [[Demystifying C++ - Cleanup Code|クリーンアップコード]]
* [[Demystifying C++ - Range-Based for Loops|範囲ベースのforループ]]

== 未来のアイディア ==

* メンバ関数ポインタ
* 配列のnewとdelete
* 例外処理

[[Category:Demystifying C++|!Demystifying_C++]]

Translations:Demystifying C++/11/en

2023-10-30T09:59:28Z

FuzzyBot: Importing a new version from external source

[[File:Demystifying C++ Ghost.png|alt=|thumb|Demystifying C++]]

Translations:Demystifying C++/1/en

2023-10-30T09:59:28Z

FuzzyBot: Importing a new version from external source

Demystifying C++/en

2023-10-30T09:38:07Z

FuzzyBot: Updating to match new version of source page

[[File:Demystifying C++ Ghost.png|alt=|thumb|Demystifying C++]]
In the world of programming, there is a constant evolution and adaptation of languages and tools to meet the ever-growing demands of software development. While C++ is considered one of the most powerful and versatile programming languages, its complexity can often be intimidating and challenging. In this article, we take a look behind the scenes and demystify the sometimes complex C++ constructs through the lens of a C++ to C transpiler. Whether you are an experienced developer or someone just delving into the depths of C++, this article offers fascinating insights into the machinery that drives this powerful language.

==C++ to C Transpiler==
A transpiler, also known as a source-to-source compiler, is a special tool that translates the source code of one programming language into the source code of another programming language. Unlike traditional compilers that translate source code into machine code, transpilers convert code from one high-level language to another.

At emmtrix, a C++ to C transpiler is currently under development [https://www.emmtrix.com/tools/emmtrix-cpp-to-c-compiler]. It is based on the tried-and-true clang frontend, a state-of-the-art compiler frontend that is part of the broader LLVM project. A standout feature is ensuring semantic equivalence between the original C++ code and the generated C code. This means that despite the differences between the two languages, the translated code exhibits the same behavior as the original code.

To ensure semantic equivalence, a comparison tool is used. This tool translates both the original C++ code and the generated C code into the LLVM IR (Intermediate Representation) and compares these two representations. Through this comparison, it can be ensured that the generated code not only produces the same output in test cases but also that semantically identical code is produced on every run (or an error is displayed). This approach is recognized as a method for ensuring error-free operation in both ISO26262 and DO-178C.

The transpiler supports all C++14 language features as well as common GCC/Clang language extensions. Only exceptions are not fully supported because they cannot be replicated in C on a 1-to-1 basis. In addition to the C++ standard, the Itanium C++ ABI [https://itanium-cxx-abi.github.io/cxx-abi/abi.html] is used, which specifies the binary interface (i.e., application binary interface, ABI), for example, how classes with inheritance are implemented.

Within the article, the transpiler is used to demystify C++ because the C output makes the implementation of the C++ constructs by the compiler easily understandable.

==C++ Construct==
* [[Demystifying C++ - Classes|Classes]]
* [[Demystifying C++ - Virtual Classes (Polymorphism)|Virtual classes (polymorphism)]]
* [[Demystifying C++ - New and Delete Operators|New and delete operators]]
* [[Demystifying C++ - Initialization of Global Variables|Initialization of global variables]]
* [[Demystifying C++ - Templates|Templates]]
* [[Demystifying C++ - Cleanup Code|Cleanup code]]
* [[Demystifying C++ - Range-Based for Loops|Range-based for loops]]

== Ideas for Future ==

* Member function pointers
* Array new and delete
* Exceptions

[[Category:Demystifying C++|!Demystifying_C++]]

Translations:Demystifying C++/10/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

[[Category:Demystifying C++|!Demystifying_C++]]

Translations:Demystifying C++/9/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

* Member function pointers
* Array new and delete
* Exceptions

Translations:Demystifying C++/8/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

== Ideas for Future ==

Translations:Demystifying C++/7/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

==C++ Construct==
* [[Demystifying C++ - Classes|Classes]]
* [[Demystifying C++ - Virtual Classes (Polymorphism)|Virtual classes (polymorphism)]]
* [[Demystifying C++ - New and Delete Operators|New and delete operators]]
* [[Demystifying C++ - Initialization of Global Variables|Initialization of global variables]]
* [[Demystifying C++ - Templates|Templates]]
* [[Demystifying C++ - Cleanup Code|Cleanup code]]
* [[Demystifying C++ - Range-Based for Loops|Range-based for loops]]

Translations:Demystifying C++/6/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

Within the article, the transpiler is used to demystify C++ because the C output makes the implementation of the C++ constructs by the compiler easily understandable.

Translations:Demystifying C++/5/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

The transpiler supports all C++14 language features as well as common GCC/Clang language extensions. Only exceptions are not fully supported because they cannot be replicated in C on a 1-to-1 basis. In addition to the C++ standard, the Itanium C++ ABI [https://itanium-cxx-abi.github.io/cxx-abi/abi.html] is used, which specifies the binary interface (i.e., application binary interface, ABI), for example, how classes with inheritance are implemented.

Translations:Demystifying C++/4/en

2023-10-30T09:38:06Z

FuzzyBot: Importing a new version from external source

To ensure semantic equivalence, a comparison tool is used. This tool translates both the original C++ code and the generated C code into the LLVM IR (Intermediate Representation) and compares these two representations. Through this comparison, it can be ensured that the generated code not only produces the same output in test cases but also that semantically identical code is produced on every run (or an error is displayed). This approach is recognized as a method for ensuring error-free operation in both ISO26262 and DO-178C.