user23860: I'm just curious, I'm going through a C++ library for the mcu2.4 TFT display.
And this method I notice when I run through C++ libraries.
Which is when a parameter is passed through a function, it's stored in a private variable; like this one:
HCTFT::HCTFT(byte DisplayType)
{
    _Display = DisplayType;

What's the benefit of this method? What's the similar method when I want to do it in C code?

user7508: Michel Keijzers explained pretty well the purpose of that idiom. Just to
complement his answer, you can do exactly the same in C, only with a
slightly different syntax:
typedef struct {
    byte _Display;
    // ...
} HCTFT;

HCTFT_construct(HCTFT *this, byte DisplayType)
{
    this->_Display = DisplayType;
    // ...
}

Now, every function that receives a pointer to an HCTFT (a HCTFT
“method”) has access to that data as a member of the struct.

user23841: That is more Object Oriented Programing question than the Arduino related.
Encapsulation is one of the fundamentals of OOP and it's basically you'll provide some interface to the object and the outside world doesn't have to know anything about it's internals (so it's not possible to change it into inconsistent state).

user31105: The reason is that _Display will be used probably after its construction.
So you pass the byte during construction, and afterwards the value is available during the object's lifetime. 
In C you probably will do this by:

Passing the variable (byte DisplayType) in each function where the value is needed (you can use this way in C++ too but it's cumbersome in both C/C++ to pass the variable in all functions needed).
Storing it in a global variable (static for that .c file); this is the typically C method.

* Added explanation *
Such a variable is called class variables and are mostly made private. The reason is that other objects cannot change the value directly. The only way to change a variable is:

By initializing it in the class constructor (like in your example). 
Within the class itself (by any method).
By a typical Set method (like SetDisplayType). This method can check if the value passed is within a range, and there is only one entry point in this class to change it. 

To retrieve the value, typically a GetDisplayType method should be created which is public. The variable itself is private.

23860: <p>I'm just curious, I'm going through a C++ library for the mcu2.4 TFT display.</p>

<p>And this method I notice when I run through C++ libraries.</p>

<p>Which is when a parameter is passed through a function, it's stored in a private variable; like this one:</p>

<pre><code>HCTFT::HCTFT(byte DisplayType)
{
    _Display = DisplayType;
</code></pre>

<p>What's the benefit of this method? What's the similar method when I want to do it in C code?</p>
 7508: <p>Michel Keijzers explained pretty well the purpose of that idiom. Just to
complement his answer, you can do exactly the same in C, only with a
slightly different syntax:</p>

<pre class="lang-c prettyprint-override"><code>typedef struct {
    byte _Display;
    // ...
} HCTFT;

HCTFT_construct(HCTFT *this, byte DisplayType)
{
    this-&gt;_Display = DisplayType;
    // ...
}
</code></pre>

<p>Now, every function that receives a pointer to an <code>HCTFT</code> (a HCTFT
“method”) has access to that data as a member of the struct.</p>
 23841: <p>That is more <em>Object Oriented Programing</em> question than the Arduino related.</p>

<p>Encapsulation is one of the fundamentals of OOP and it's basically you'll provide some interface to the object and the outside world doesn't have to know anything about it's internals (so it's not possible to change it into inconsistent state).</p>
 31105: <p>The reason is that _Display will be used probably after its construction.</p>

<p>So you pass the byte during construction, and afterwards the value is available during the object's lifetime. </p>

<p>In C you probably will do this by:</p>

<ul>
<li>Passing the variable (byte DisplayType) in each function where the value is needed (you can use this way in C++ too but it's cumbersome in both C/C++ to pass the variable in all functions needed).</li>
<li>Storing it in a global variable (static for that .c file); this is the typically C method.</li>
</ul>

<p><strong>* Added explanation *</strong></p>

<p>Such a variable is called class variables and are mostly made private. The reason is that other objects cannot change the value directly. The only way to change a variable is:</p>

<ol>
<li>By initializing it in the class constructor (like in your example). </li>
<li>Within the class itself (by any method).</li>
<li>By a typical Set method (like SetDisplayType). This method can check if the value passed is within a range, and there is only one entry point in this class to change it. </li>
</ol>

<p>To retrieve the value, typically a GetDisplayType method should be created which is public. The variable itself is private.</p>
