blob: cdb2b04d9ce0f5930805bbe1cc15014c5044091a [file] [log] [blame]
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<!-- Copyright (C) 1988-2015 Free Software Foundation, Inc.
Permission is granted to copy, distribute and/or modify this document
under the terms of the GNU Free Documentation License, Version 1.3 or
any later version published by the Free Software Foundation; with the
Invariant Sections being "Funding Free Software", the Front-Cover
Texts being (a) (see below), and with the Back-Cover Texts being (b)
(see below). A copy of the license is included in the section entitled
"GNU Free Documentation License".
(a) The FSF's Front-Cover Text is:
A GNU Manual
(b) The FSF's Back-Cover Text is:
You have freedom to copy and modify this GNU Manual, like GNU
software. Copies published by the Free Software Foundation raise
funds for GNU development. -->
<!-- Created by GNU Texinfo 5.2, http://www.gnu.org/software/texinfo/ -->
<head>
<title>Using the GNU Compiler Collection (GCC): Compound Literals</title>
<meta name="description" content="Using the GNU Compiler Collection (GCC): Compound Literals">
<meta name="keywords" content="Using the GNU Compiler Collection (GCC): Compound Literals">
<meta name="resource-type" content="document">
<meta name="distribution" content="global">
<meta name="Generator" content="makeinfo">
<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
<link href="index.html#Top" rel="start" title="Top">
<link href="Option-Index.html#Option-Index" rel="index" title="Option Index">
<link href="index.html#SEC_Contents" rel="contents" title="Table of Contents">
<link href="C-Extensions.html#C-Extensions" rel="up" title="C Extensions">
<link href="Designated-Inits.html#Designated-Inits" rel="next" title="Designated Inits">
<link href="Initializers.html#Initializers" rel="prev" title="Initializers">
<style type="text/css">
<!--
a.summary-letter {text-decoration: none}
blockquote.smallquotation {font-size: smaller}
div.display {margin-left: 3.2em}
div.example {margin-left: 3.2em}
div.indentedblock {margin-left: 3.2em}
div.lisp {margin-left: 3.2em}
div.smalldisplay {margin-left: 3.2em}
div.smallexample {margin-left: 3.2em}
div.smallindentedblock {margin-left: 3.2em; font-size: smaller}
div.smalllisp {margin-left: 3.2em}
kbd {font-style:oblique}
pre.display {font-family: inherit}
pre.format {font-family: inherit}
pre.menu-comment {font-family: serif}
pre.menu-preformatted {font-family: serif}
pre.smalldisplay {font-family: inherit; font-size: smaller}
pre.smallexample {font-size: smaller}
pre.smallformat {font-family: inherit; font-size: smaller}
pre.smalllisp {font-size: smaller}
span.nocodebreak {white-space:nowrap}
span.nolinebreak {white-space:nowrap}
span.roman {font-family:serif; font-weight:normal}
span.sansserif {font-family:sans-serif; font-weight:normal}
ul.no-bullet {list-style: none}
-->
</style>
</head>
<body lang="en" bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080" alink="#FF0000">
<a name="Compound-Literals"></a>
<div class="header">
<p>
Next: <a href="Designated-Inits.html#Designated-Inits" accesskey="n" rel="next">Designated Inits</a>, Previous: <a href="Initializers.html#Initializers" accesskey="p" rel="prev">Initializers</a>, Up: <a href="C-Extensions.html#C-Extensions" accesskey="u" rel="up">C Extensions</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
</div>
<hr>
<a name="Compound-Literals-1"></a>
<h3 class="section">6.25 Compound Literals</h3>
<a name="index-constructor-expressions"></a>
<a name="index-initializations-in-expressions"></a>
<a name="index-structures_002c-constructor-expression"></a>
<a name="index-expressions_002c-constructor"></a>
<a name="index-compound-literals"></a>
<p>ISO C99 supports compound literals. A compound literal looks like
a cast containing an initializer. Its value is an object of the
type specified in the cast, containing the elements specified in
the initializer; it is an lvalue. As an extension, GCC supports
compound literals in C90 mode and in C++, though the semantics are
somewhat different in C++.
</p>
<p>Usually, the specified type is a structure. Assume that
<code>struct foo</code> and <code>structure</code> are declared as shown:
</p>
<div class="smallexample">
<pre class="smallexample">struct foo {int a; char b[2];} structure;
</pre></div>
<p>Here is an example of constructing a <code>struct foo</code> with a compound literal:
</p>
<div class="smallexample">
<pre class="smallexample">structure = ((struct foo) {x + y, 'a', 0});
</pre></div>
<p>This is equivalent to writing the following:
</p>
<div class="smallexample">
<pre class="smallexample">{
struct foo temp = {x + y, 'a', 0};
structure = temp;
}
</pre></div>
<p>You can also construct an array, though this is dangerous in C++, as
explained below. If all the elements of the compound literal are
(made up of) simple constant expressions, suitable for use in
initializers of objects of static storage duration, then the compound
literal can be coerced to a pointer to its first element and used in
such an initializer, as shown here:
</p>
<div class="smallexample">
<pre class="smallexample">char **foo = (char *[]) { &quot;x&quot;, &quot;y&quot;, &quot;z&quot; };
</pre></div>
<p>Compound literals for scalar types and union types are
also allowed, but then the compound literal is equivalent
to a cast.
</p>
<p>As a GNU extension, GCC allows initialization of objects with static storage
duration by compound literals (which is not possible in ISO C99, because
the initializer is not a constant).
It is handled as if the object is initialized only with the bracket
enclosed list if the types of the compound literal and the object match.
The initializer list of the compound literal must be constant.
If the object being initialized has array type of unknown size, the size is
determined by compound literal size.
</p>
<div class="smallexample">
<pre class="smallexample">static struct foo x = (struct foo) {1, 'a', 'b'};
static int y[] = (int []) {1, 2, 3};
static int z[] = (int [3]) {1};
</pre></div>
<p>The above lines are equivalent to the following:
</p><div class="smallexample">
<pre class="smallexample">static struct foo x = {1, 'a', 'b'};
static int y[] = {1, 2, 3};
static int z[] = {1, 0, 0};
</pre></div>
<p>In C, a compound literal designates an unnamed object with static or
automatic storage duration. In C++, a compound literal designates a
temporary object, which only lives until the end of its
full-expression. As a result, well-defined C code that takes the
address of a subobject of a compound literal can be undefined in C++.
For instance, if the array compound literal example above appeared
inside a function, any subsequent use of &lsquo;<samp>foo</samp>&rsquo; in C++ has
undefined behavior because the lifetime of the array ends after the
declaration of &lsquo;<samp>foo</samp>&rsquo;. As a result, the C++ compiler now rejects
the conversion of a temporary array to a pointer.
</p>
<p>As an optimization, the C++ compiler sometimes gives array compound
literals longer lifetimes: when the array either appears outside a
function or has const-qualified type. If &lsquo;<samp>foo</samp>&rsquo; and its
initializer had elements of &lsquo;<samp>char *const</samp>&rsquo; type rather than
&lsquo;<samp>char *</samp>&rsquo;, or if &lsquo;<samp>foo</samp>&rsquo; were a global variable, the array
would have static storage duration. But it is probably safest just to
avoid the use of array compound literals in code compiled as C++.
</p>
<hr>
<div class="header">
<p>
Next: <a href="Designated-Inits.html#Designated-Inits" accesskey="n" rel="next">Designated Inits</a>, Previous: <a href="Initializers.html#Initializers" accesskey="p" rel="prev">Initializers</a>, Up: <a href="C-Extensions.html#C-Extensions" accesskey="u" rel="up">C Extensions</a> &nbsp; [<a href="index.html#SEC_Contents" title="Table of contents" rel="contents">Contents</a>][<a href="Option-Index.html#Option-Index" title="Index" rel="index">Index</a>]</p>
</div>
</body>
</html>