-The meaning of a value stored in an object or returned by a function is determined by the type of the expression used to access it. (An identifier declared to be an object is the simplest such expression; the type is specified in the declaration of the identifier.) Types are partitioned into object types(types that fully describe object) and function types(types that describe functions).
-
-An object declares as type bool is large enough to store the values 0 and 1.
-
-An object declared as type char is large enough to store any member of the basic execution character set. If a member of the basic execution character set is stored in a char object, its value is guaranteed to be nonnegative. If any other character is stored in a char, the resulting value is implemented-defined.
-
-An object declared as type string is large enough to store any length string-literal composed of any length chars, and as such follows the same rules as an object declared as type char.
-
-The void type comprises an empty set of values; it is an incomplete type that cannot be completed.
-
-The float and vector type .. TODO
-
-An enumeration comprises a set of named integer constant values. Each enumeration constitutes a different enumerated type.
-
-\subsubsection{Compatible type and composite type}
-Two types have compatibility if their types are the same.
+The meaning of a value stored in an object returned by a function is determined by the
+type of the expression used to access it. (An identifier declared to be an object is the simplest
+such expression; the type is specified in the declaration of the identifier.) Types are
+partitioned into object types (types that fully describe objects), function types(types
+that describe functions), and incomplete types(types that describe objects but lack
+information).
+\linebreak
+
+An object declared type bool is large enough to store the values 0 and 1.
+\linebreak
+
+An object declared type float is a real type; An object declared type vector is a
+comprised set of three floats that respectively represent the \underline{x,y,z}
+components of a three-dimensional vector.
+\linebreak
+
+An enumeration comprises a set of named integer constant values. Each distinct
+enumeration constitutes a different enumerated type.
+\linebreak
+
+Enumeration types and float are collectively called arithmetic types. Each arithmetic
+type belongs to one type domain.
+\linebreak
+
+The void type comprises an empty set of values; it is an incomplete type that cannot be
+completed.
+\linebreak
+
+A number of derived types can be constructed from the object, function and incomplete
+types, as follows:
+\linebreak
+
+\begin{itemize}
+ \item An array type describes a contiguously allocated nonempty set of objects with a
+ particular object types, called the element type. Array types are characterized
+ by their element type and by the number of elements in the array. An array type
+ is said to be derived from its element type, and if its element is type T, the
+ array type is sometimes called "array of T". The construction of an array type
+ from an element type is called "array type derivation".
+ \item A function type described a function with a specified return type. A function
+ type is characterized by its return type and the number and types of its
+ parameters. A function type is said to be derived from its return type, and if
+ its return type is T, the function type is sometimes called "function returning
+ T". The construction of a function type from a return type is called "function
+ type derivation".
+\end{itemize}
+
+Arithmetic types are collectively called scalar types. Arrays and vectors are
+collectively called aggregate types.
+\linebreak
+
+An array of unknown size is an incomplete type. It is completed, for an identifier of
+that byte, by specifying the size in a later declaration. Arrays are required to have
+known constant size.
+\linebreak
+
+A type is characterized by its type category, which is either the outermost derivation
+of a derived type (as noted above in the construction of derived types), or the type
+itself if the type consists of no derived types.
+\linebreak
+
+Any type so far mentioned is an unqualified type. Each unqualified type has several
+qualified version of its type, corresponding to the combinations of one, two, or all
+two of const and volatile qualifiers. The qualified or unqualified versions of a type
+are distinct types that belong to the same type category and have the same representation.
+A derived type is not qualified by the qualifiers (if any) of the type from which it
+is derived.
+\linebreak
+
+%% ->-> Compatible types and composite type %%
+\subsubsection{Compatible types and composite type}
+Two types have compatible type if their types are the same.
+\linebreak
+
+All declarations that refer to the same object or function shall have compatible type;
+otherwise the behavior is undefined.
+\linebreak
+
+A composite type can be constructed from two types that are compatible; it is a type that
+is compatible with both of the two types and satisfies the following conditions:
+\begin{itemize}
+ \item If one type is an array, the composite type is an array of that size.
+ \item If only one type is a function type with a parameter type list(a function
+ prototype), the composite type is a function prototype with the parameter type
+ list.
+ \item If both types are function types with parameter type lists, the type of each
+ parameter in the composite parameter type list is the composite type of the
+ corresponding parameters.
+\end{itemize}
+These rules apply recursively to types from which the twp types are derived.
+\linebreak
+
+%% ->Conversions %%
+\subsection{Conversions}
+Several operators convert operand values from one type to another automatically. This
+sub-clause specified the result required from such an implicit conversion.
+\linebreak