C++ 学习

最新推荐文章于 2023-04-17 09:22:17 发布

bbzz2

最新推荐文章于 2023-04-17 09:22:17 发布

阅读量423

点赞数

类的四个合成和MyString类的实现

合成即默认，由编译器自动生成并隐式调用。构造、复制构造、析构、赋值操作符分别对对象的初始化、复制、撤销、赋值进行操作。理解这些概念稍微要花点时间，但是理解了还要不断的实践，才能够得心应手，信手拈来。

1 合成构造函数

构造函数的一般特性：

构造函数的名字与类的名字相同，且不能指定返回类型
构造函数可以重载，即形参表可以多样
因为构造函数是用来初始化变量，所以const构造函数是不可行的
构造函数的初始化列表只在构造函数的定义中而不是声明中指定
某些数据成员必须使用构造函数初始化列表来初始化：任何的常量（const）成员、引用类型成员、没有默认构造函数的类类型成员。注意，非const引用只能绑定到与该引用同类型的对象，const引用则可以绑定到不同但相关的类型的对象或绑定到右值
数据成员在构造函数的初始化列表中的初始化次序是按照成员被声明的次序是相同的，因此，初始化类表中也应按照这个次序来初始化，防止一个成员是根据其他成员而初始化的，但是次序不跟声明的次序相同的这种情况发生
通常，除非有明显的理由想要定义隐式转化，否则，单形参构造函数应该为explicit修饰，这样，用户需通过显示的构造对象才能通过，注意，explicit关键字只能用于类内部的构造函数声明上

合成构造函数：

只有当一个类没有定义构造函数（包括复制构造函数）时，编译器才会自动生成一个默认的构造函数
如果定义了其他的构造函数，那么显示定义一个无参构造函数（默认构造函数）总是安全的

2 合成的复制构造函数

复制构造函数的一般特性：

当对另一个同类型的对象显式或隐式初始化，会调用复制构造函数
将一个对象作为实参传给一个函数（非引用类型或非指针类型），会调用复制构造函数
函数返回一个对象时，会调用复制构造函数
初始化顺序容器中的元素时，会调用复制构造函数
根据元素初始化式类表初始化数组元素时，会调用复制构造函数
IO类型的对象不能复制，因此对此类对象需要防止复制初始化，如私有化复制构造函数
通过声明（但不定义）private复制构造函数，可以禁止任何复制类类型对象的尝试，包括友元中的函数和成员函数

合成的复制构造函数：

合成复制构造函数的行为是，执行逐个成员初始化（非static成员），即将新对象初始化为原对象的副本，当成员为类类型的时候，则使用该类的复制构造函数进行复制。特殊情况就是数组成员也能够复制。
当成员包含指针类型的成员或者有成员表示在构造函数中分配的其他资源，都需要重新显示定义复制构造函数。原因是初始化只是复制原对象的副本，所以指针也只是复制，即原对象和新对象的指针成员共同指向同一块内存，当一个对象释放内存后，再释放另一个对象，那么就会造成重释放（double free）错误
没有定义复制构造函数时，编译器就会为我们合成一个，即使定义了其他的构造函数（非复制构造函数），也会合成复制构造函数

3 合成析构函数

不带任何参数，且和构造函数一样没有返回值，因此析构函数是不能重载的
即使自定义了析构函数，编译器也总是会为我们合成一个析构函数，并且如果自定义了析构函数，编译器在执行时会先调用自定义的析构函数（手动释放堆上内存）再调用合成的析构函数（不会释放堆上的内存）
析构函数按对象创建时的逆序撤销每个非static成员(栈上面的成员)
析构函数并不删除指针成员所指向的对象，因此需要手动去释放内存

4 合成赋值操作符

赋值操作符的一般特性：

如果类没有定义自己的赋值操作符，同样的，编译器也会合成一个
显示定义赋值操作符，则是重载赋值操作符
大多数操作符可以定义为成员函数或非成员函数，当操作符为成员函数时，它的第一个操作数隐式绑定到了this指针，赋值操作符也是如此，但赋值操作符必须定义自己的类的成员，因为赋值必须是类的成员，如定义自己的String类，

5 相关概念理解

explicit

C++中，只有一个参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造函数)，承担了两个角色。 1 是个构造器，2 是个默认且隐含的类型转换操作符。
所以，有时候在我们写下如 MyClass object = type，这样的代码，且恰好type的类型正好是MyClass单参数构造器的参数类型，这时候编译器就自动调用这个构造器，创建一个MyClass类型的对象。

heap

堆区（heap）,一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式倒是类似于链表。

stack

栈区（stack）,由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

6 实例—MyString类的实现

下面的MyString类的实现很好的对上面的概念进行了实践，通过实验，可以比较好的理解上面的理论知识。

【MyString.h】

<code class="language-c++ hljs cs has-numbering"><span class="hljs-preprocessor">#<span class="hljs-keyword">pragma</span> once</span>

<span class="hljs-preprocessor">#<span class="hljs-keyword">define</span> _CRT_SECURE_NO_WARNINGS</span>

<span class="hljs-preprocessor">#include <iostream></span>

<span class="hljs-keyword">using</span> namespace std;

class MyString
{
    friend ostream& <span class="hljs-keyword">operator</span><<(ostream& os,<span class="hljs-keyword">const</span> MyString &);
    friend MyString <span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>*, <span class="hljs-keyword">const</span> MyString&);
<span class="hljs-keyword">public</span>:
    <span class="hljs-title">MyString</span>(<span class="hljs-keyword">void</span>);
    MyString(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *);
    MyString(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *, <span class="hljs-keyword">int</span>);
    MyString(<span class="hljs-keyword">const</span> MyString&);
    ~MyString(<span class="hljs-keyword">void</span>);
<span class="hljs-keyword">public</span>:
    MyString& <span class="hljs-keyword">operator</span>=(<span class="hljs-keyword">const</span> MyString &);
    MyString& <span class="hljs-keyword">operator</span>=(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *);

    <span class="hljs-keyword">char</span>& <span class="hljs-keyword">operator</span>[](<span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span>);
    <span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>& <span class="hljs-keyword">operator</span>[](<span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span>)<span class="hljs-keyword">const</span>;

    MyString <span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> MyString&);
    MyString <span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> MyString&) <span class="hljs-keyword">const</span>;
    MyString <span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>*);
<span class="hljs-keyword">public</span>:
    <span class="hljs-keyword">int</span> <span class="hljs-title">size</span>();
<span class="hljs-keyword">private</span>:
    <span class="hljs-keyword">int</span> m_len;
    <span class="hljs-keyword">char</span> * m_str;
};</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li><li>33</li><li>34</li></ul>

【MyString.cpp】

<code class="language-c++ hljs cpp has-numbering"><span class="hljs-preprocessor">#include "MyString.h"</span>
<span class="hljs-preprocessor">#include <string.h></span>


<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//MyString初始化、复制、赋值函数</span>
<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//显式定义默认构造函数</span>
MyString::MyString(<span class="hljs-keyword">void</span>)
{
    <span class="hljs-comment">//默认构造函数将长度置为0</span>
    m_len = <span class="hljs-number">0</span>;
    <span class="hljs-comment">//可以直接将m_str初始化为0,即分配了一个字符的堆(heap)内存空间,释放内存时，同样的用数组的释放</span>
    <span class="hljs-comment">//方式（加了方括号对），也能够释放，但是对于大小大于1的数组，缺少方括号对，则会少释放内存空间</span>
    <span class="hljs-comment">//m_str = new char();                </span>
    <span class="hljs-comment">//动态长度为0的数组，new返回有效的非零指针，该指针不能够解引用操作</span>
    m_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[<span class="hljs-number">0</span>];                
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"MyString(void)"</span> << endl;
}
<span class="hljs-comment">//参数为const char* str构造函数</span>
MyString::MyString(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> * str)
{
    m_len = <span class="hljs-built_in">strlen</span>(str);
    m_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[m_len+<span class="hljs-number">1</span>];
    <span class="hljs-built_in">memset</span>(m_str,<span class="hljs-number">0</span>,m_len+<span class="hljs-number">1</span>);
    <span class="hljs-built_in">strncpy</span>(m_str,str,m_len);
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"MyString(const char * str)"</span> << endl;
}

<span class="hljs-comment">//显式定义复制构造函数</span>
MyString::MyString(<span class="hljs-keyword">const</span> MyString& mystring)
{
    m_len = mystring.m_len;
    m_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[m_len+<span class="hljs-number">1</span>];
    <span class="hljs-built_in">memset</span>(m_str,<span class="hljs-number">0</span>,m_len+<span class="hljs-number">1</span>);
    <span class="hljs-built_in">strncpy</span>(m_str,mystring.m_str,mystring.m_len);
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"MyString(const MyString& mystring)"</span> << endl;
}

<span class="hljs-comment">//字符串常量 len=sizeof("xxx");</span>
<span class="hljs-comment">//字符指针或数组 len = strlen(xxx)+1;</span>
MyString::MyString(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> * str,<span class="hljs-keyword">int</span> len)
{
    m_len = len;
    m_str = (<span class="hljs-keyword">char</span> *)<span class="hljs-built_in">malloc</span>(m_len+<span class="hljs-number">1</span>);
    <span class="hljs-built_in">memset</span>(m_str,<span class="hljs-number">0</span>,m_len+<span class="hljs-number">1</span>);
    <span class="hljs-built_in">strncpy</span>(m_str,str,m_len);
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"MyString(const char * str,int len)"</span> <<endl;
}

<span class="hljs-comment">//析构函数</span>
MyString::~MyString(<span class="hljs-keyword">void</span>)
{
    <span class="hljs-comment">//两种释放内存的方式均可？</span>
    <span class="hljs-keyword">delete</span> [] m_str;
    <span class="hljs-comment">//delete m_str;</span>
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"~MyString(void)"</span> <<endl;
}
<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//友元函数</span>
<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//输出操作符重载</span>
ostream& <span class="hljs-keyword">operator</span><<(ostream& os,<span class="hljs-keyword">const</span> MyString &mystring)
{
    os << mystring.m_str;
    <span class="hljs-keyword">return</span> os;
}
MyString <span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* cstr,  <span class="hljs-keyword">const</span> MyString& str) {
    MyString ms1 = cstr;
    MyString ms2 = str + ms1;
    <span class="hljs-keyword">return</span> ms2;

}
<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//操作符重载</span>
<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//赋值操作符重载：包含指针，跟复制构造函数一样，对指针只是按成员复制，所以需重载</span>
MyString& MyString::<span class="hljs-keyword">operator</span>=(<span class="hljs-keyword">const</span> MyString & mystring)
{
    <span class="hljs-keyword">if</span> (&mystring == <span class="hljs-keyword">this</span>)
    {
        <span class="hljs-built_in">cout</span> << <span class="hljs-string">"不能够复制自己"</span> << endl;
        <span class="hljs-keyword">return</span> *<span class="hljs-keyword">this</span>;
    }

    <span class="hljs-keyword">delete</span> [] m_str;

    m_len = mystring.m_len;
    m_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[m_len+<span class="hljs-number">1</span>];
    <span class="hljs-built_in">memset</span>(m_str,<span class="hljs-number">0</span>,m_len+<span class="hljs-number">1</span>);
    <span class="hljs-built_in">strncpy</span>(m_str,mystring.m_str,mystring.m_len);
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"operator=(const MyString & mystring)"</span> <<endl;
    <span class="hljs-keyword">return</span> *<span class="hljs-keyword">this</span>;
}

MyString& MyString::<span class="hljs-keyword">operator</span>=(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span> *str)
{
    <span class="hljs-keyword">delete</span> [] m_str;

    m_len = <span class="hljs-built_in">strlen</span>(str);
    m_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[m_len+<span class="hljs-number">1</span>];
    <span class="hljs-built_in">memset</span>(m_str,<span class="hljs-number">0</span>,m_len+<span class="hljs-number">1</span>);
    <span class="hljs-built_in">strncpy</span>(m_str,str,m_len);
    <span class="hljs-built_in">cout</span> << <span class="hljs-string">"operator=(const char *str)"</span> <<endl;
    <span class="hljs-keyword">return</span> *<span class="hljs-keyword">this</span>;
}

<span class="hljs-keyword">char</span>& MyString::<span class="hljs-keyword">operator</span>[](<span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> index)
{
    <span class="hljs-keyword">if</span>(index >= m_len && index < <span class="hljs-number">0</span>){
        <span class="hljs-built_in">cout</span> << <span class="hljs-string">"下标操作溢出"</span> << endl;
        <span class="hljs-built_in">exit</span>(-<span class="hljs-number">1</span>);
    }
    <span class="hljs-keyword">return</span> m_str[index];
}
<span class="hljs-comment">//const char& MyString::operator[](const int index) const;</span>
<span class="hljs-comment">//char& MyString::operator[](const int index) const;</span>
<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>& MyString::<span class="hljs-keyword">operator</span>[](<span class="hljs-keyword">const</span> <span class="hljs-keyword">int</span> index) <span class="hljs-keyword">const</span>
{
    <span class="hljs-keyword">if</span>(index >= m_len && index < <span class="hljs-number">0</span>){
        <span class="hljs-built_in">cout</span> << <span class="hljs-string">"下标操作溢出"</span> << endl;
        <span class="hljs-built_in">exit</span>(-<span class="hljs-number">1</span>);
    }
    <span class="hljs-keyword">return</span> m_str[index];
}
<span class="hljs-comment">//+操作符重载</span>
MyString MyString::<span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> <span class="hljs-keyword">char</span>* cstr) {
    <span class="hljs-keyword">char</span>* new_str;

    <span class="hljs-keyword">int</span> new_size = <span class="hljs-built_in">strlen</span>(cstr) + m_len + <span class="hljs-number">1</span>;
    new_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[new_size];
    <span class="hljs-built_in">memset</span>(new_str,<span class="hljs-number">0</span>,new_size);

    <span class="hljs-built_in">strcpy</span>(new_str, m_str);
    <span class="hljs-built_in">strcat</span>(new_str, cstr);

    MyString ms = new_str;
    <span class="hljs-keyword">delete</span> new_str;

    <span class="hljs-keyword">return</span> ms;   
}

MyString MyString::<span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> MyString& str) <span class="hljs-keyword">const</span> {
    <span class="hljs-keyword">char</span>* temp_str;

    <span class="hljs-keyword">int</span> temp_size = <span class="hljs-built_in">strlen</span>(str.m_str) + m_len + <span class="hljs-number">1</span>;
    temp_str = <span class="hljs-keyword">new</span> <span class="hljs-keyword">char</span>[temp_size];
    <span class="hljs-built_in">memset</span>(temp_str,<span class="hljs-number">0</span>,temp_size);

    <span class="hljs-built_in">strcpy</span>(temp_str, m_str);
    <span class="hljs-built_in">strcat</span>(temp_str, str.m_str);

    MyString ms = temp_str;
    <span class="hljs-keyword">delete</span> temp_str;

    <span class="hljs-keyword">return</span> ms; 
}

MyString MyString::<span class="hljs-keyword">operator</span>+(<span class="hljs-keyword">const</span> MyString& str) {
    <span class="hljs-keyword">return</span> (*<span class="hljs-keyword">this</span> + str.m_str);
}

<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//MyString功能函数，可扩展</span>
<span class="hljs-comment">//--------------------------------------------------------------</span>
<span class="hljs-comment">//得到mystring的大小</span>
<span class="hljs-keyword">int</span> MyString::size()
{
    <span class="hljs-keyword">return</span> m_len;    
}</code><ul class="pre-numbering" style="display: block;"><li>1</li><li>2</li><li>3</li><li>4</li><li>5</li><li>6</li><li>7</li><li>8</li><li>9</li><li>10</li><li>11</li><li>12</li><li>13</li><li>14</li><li>15</li><li>16</li><li>17</li><li>18</li><li>19</li><li>20</li><li>21</li><li>22</li><li>23</li><li>24</li><li>25</li><li>26</li><li>27</li><li>28</li><li>29</li><li>30</li><li>31</li><li>32</li><li>33</li><li>34</li><li>35</li><li>36</li><li>37</li><li>38</li><li>39</li><li>40</li><li>41</li><li>42</li><li>43</li><li>44</li><li>45</li><li>46</li><li>47</li><li>48</li><li>49</li><li>50</li><li>51</li><li>52</li><li>53</li><li>54</li><li>55</li><li>56</li><li>57</li><li>58</li><li>59</li><li>60</li><li>61</li><li>62</li><li>63</li><li>64</li><li>65</li><li>66</li><li>67</li><li>68</li><li>69</li><li>70</li><li>71</li><li>72</li><li>73</li><li>74</li><li>75</li><li>76</li><li>77</li><li>78</li><li>79</li><li>80</li><li>81</li><li>82</li><li>83</li><li>84</li><li>85</li><li>86</li><li>87</li><li>88</li><li>89</li><li>90</li><li>91</li><li>92</li><li>93</li><li>94</li><li>95</li><li>96</li><li>97</li><li>98</li><li>99</li><li>100</li><li>101</li><li>102</li><li>103</li><li>104</li><li>105</li><li>106</li><li>107</li><li>108</li><li>109</li><li>110</li><li>111</li><li>112</li><li>113</li><li>114</li><li>115</li><li>116</li><li>117</li><li>118</li><li>119</li><li>120</li><li>121</li><li>122</li><li>123</li><li>124</li><li>125</li><li>126</li><li>127</li><li>128</li><li>129</li><li>130</li><li>131</li><li>132</li><li>133</li><li>134</li><li>135</li><li>136</li><li>137</li><li>138</li><li>139</li><li>140</li><li>141</li><li>142</li><li>143</li><li>144</li><li>145</li><li>146</li><li>147</li><li>148</li><li>149</li><li>150</li><li>151</li><li>152</li><li>153</li><li>154</li><li>155</li><li>156</li><li>157</li><li>158</li><li>159</li><li>160</li><li>161</li><li>162</li><li>163</li><li>164</li><li>165</li><li>166</li><li>167</li><li>168</li><li>169</li><li>170</li></ul>

【main.cpp】

<code class="language-c++ hljs coffeescript has-numbering"><span class="hljs-comment">#include "MyString.h"</span>

int main(int argc,char *argv[])
{
    <span class="hljs-regexp">/*默认构造函数测试*/</span>
    MyString str0;
    <span class="hljs-regexp">/*测试形参为const char* 构造函数*/</span>
    char * cstr0 = <span class="hljs-string">"hello world"</span>;
    char cstr1[] = <span class="hljs-string">"hello world"</span>;
    MyString str1 = <span class="hljs-string">"hello world"</span>;    <span class="hljs-regexp">//</span>C++ Primer 第四版书上说会调用复制构造函数（错误）
    MyString str2(<span class="hljs-string">"hello world"</span>);
    MyString str3(cstr0);
    MyString str4(cstr1);
    MyString str5 = cstr0;
    MyString str6 = cstr1;
    /*先初始化，再调用形参为<span class="hljs-reserved">const</span> char *赋值操作符重载函数，如果屏蔽形参为<span class="hljs-reserved">const</span> char*函数，则先会隐式构造一个值为<span class="hljs-string">"world"</span>MyString类
    再调用<span class="hljs-reserved">const</span> MyString &赋值操作符重载函数
    */
    MyString str7 = <span class="hljs-string">"hello"</span>;
    str7 = <span class="hljs-string">"world"</span>;
    <span class="hljs-regexp">/*先初始化，再调用形参为const MyString &赋值操作符重载函数*/</span>
    MyString str8 = <span class="hljs-string">"hello"</span>;
    MyString str9 = <span class="hljs-string">"world"</span>;
    str8 = str9;
    /*如果重载下标操作符为char& <span class="hljs-attribute">MyString</span>::operator[](<span class="hljs-reserved">const</span> int index)<span class="hljs-reserved">const</span>;，则还可以通过下标操作来修改<span class="hljs-reserved">const</span> MyString但是对
    于<span class="hljs-reserved">const</span>修饰的MyString是不能修改的，所以需要将下标操作符重载函数改为<span class="hljs-reserved">const</span> char& <span class="hljs-attribute">MyString</span>::operator[](<span class="hljs-reserved">const</span> int index)<span class="hljs-reserved">const</span>;*/
    <span class="hljs-reserved">const</span> MyString str10 = <span class="hljs-string">"hello"</span>;
    <span class="hljs-regexp">//</span>去掉<span class="hljs-reserved">const</span> char& <span class="hljs-attribute">MyString</span>::operator[](<span class="hljs-reserved">const</span> int index)<span class="hljs-reserved">const</span>;前面的<span class="hljs-reserved">const</span>修饰，则可以修改<span class="hljs-reserved">const</span> 修饰的str10，不合理
    <span class="hljs-regexp">//</span>str10[<span class="hljs-number">0</span>] = <span class="hljs-string">'W'</span>;    
    <span class="hljs-regexp">//</span>ch = <span class="hljs-string">'e'</span>;
    char ch = str10[<span class="hljs-number">1</span>];
    <span class="hljs-regexp">//</span>+和<<号操作符重载
    MyString str11 = <span class="hljs-string">"hello "</span>;
    str11 = str11 + <span class="hljs-string">"world"</span>;
    cout << str11 << endl;
    <span class="hljs-keyword">return</span> <span class="hljs-number">0</span>;
}</code>