
<!DOCTYPE html>

<html lang="en">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
  <title>INTERFACE_SYSTEM_INCLUDE_DIRECTORIES &mdash; CMake 3.23.1 Documentation</title>

    <link rel="stylesheet" type="text/css" href="../_static/pygments.css" />
    <link rel="stylesheet" type="text/css" href="../_static/cmake.css" />
    
    <script data-url_root="../" id="documentation_options" src="../_static/documentation_options.js"></script>
    <script src="../_static/jquery.js"></script>
    <script src="../_static/underscore.js"></script>
    <script src="../_static/doctools.js"></script>
    
    <link rel="shortcut icon" href="../_static/cmake-favicon.ico"/>
    <link rel="index" title="Index" href="../genindex.html" />
    <link rel="search" title="Search" href="../search.html" />
    <link rel="next" title="INTERPROCEDURAL_OPTIMIZATION" href="INTERPROCEDURAL_OPTIMIZATION.html" />
    <link rel="prev" title="INTERFACE_SOURCES" href="INTERFACE_SOURCES.html" />
 

  </head><body>

    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             accesskey="I">index</a></li>
        <li class="right" >
          <a href="INTERPROCEDURAL_OPTIMIZATION.html" title="INTERPROCEDURAL_OPTIMIZATION"
             accesskey="N">next</a> |</li>
        <li class="right" >
          <a href="INTERFACE_SOURCES.html" title="INTERFACE_SOURCES"
             accesskey="P">previous</a> |</li>
  <li>
    <img src="../_static/cmake-logo-16.png" alt=""
         style="vertical-align: middle; margin-top: -2px" />
  </li>
  <li>
    <a href="https://cmake.org/">CMake</a> &#187;
  </li>
  <li>
    <a href="../index.html">3.23.1 Documentation</a> &#187;
  </li>

          <li class="nav-item nav-item-1"><a href="../manual/cmake-properties.7.html" accesskey="U">cmake-properties(7)</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="">INTERFACE_SYSTEM_INCLUDE_DIRECTORIES</a></li> 
      </ul>
    </div>  

    <div class="document">
      <div class="documentwrapper">
        <div class="bodywrapper">
          <div class="body" role="main">
            
  <div class="section" id="interface-system-include-directories">
<span id="prop_tgt:INTERFACE_SYSTEM_INCLUDE_DIRECTORIES"></span><h1>INTERFACE_SYSTEM_INCLUDE_DIRECTORIES<a class="headerlink" href="#interface-system-include-directories" title="Permalink to this headline">¶</a></h1>
<p>List of public system include directories for a library.</p>
<p>Targets may populate this property to publish the include directories
which contain system headers, and therefore should not result in
compiler warnings.  Additionally, system include directories are searched
after normal include directories regardless of the order specified.</p>
<p>The <span class="target" id="index-0-command:target_include_directories"></span><a class="reference internal" href="../command/target_include_directories.html#command:target_include_directories" title="target_include_directories"><code class="xref cmake cmake-command docutils literal notranslate"><span class="pre">target_include_directories(SYSTEM)</span></code></a> command signature
populates this property with values given to the <code class="docutils literal notranslate"><span class="pre">PUBLIC</span></code> and
<code class="docutils literal notranslate"><span class="pre">INTERFACE</span></code> keywords.</p>
<p>Projects may also get and set the property directly, but must be aware that
adding directories to this property does not make those directories used
during compilation.  Adding directories to this property marks directories
as <code class="docutils literal notranslate"><span class="pre">SYSTEM</span></code> which otherwise would be used in a non-<code class="docutils literal notranslate"><span class="pre">SYSTEM</span></code> manner.  This
can appear similar to 'duplication', so prefer the
high-level <span class="target" id="index-1-command:target_include_directories"></span><a class="reference internal" href="../command/target_include_directories.html#command:target_include_directories" title="target_include_directories"><code class="xref cmake cmake-command docutils literal notranslate"><span class="pre">target_include_directories(SYSTEM)</span></code></a> command and avoid
setting the property by low-level means.</p>
<p>When target dependencies are specified using <span class="target" id="index-0-command:target_link_libraries"></span><a class="reference internal" href="../command/target_link_libraries.html#command:target_link_libraries" title="target_link_libraries"><code class="xref cmake cmake-command docutils literal notranslate"><span class="pre">target_link_libraries()</span></code></a>,
CMake will read this property from all target dependencies to mark the
same include directories as containing system headers.</p>
<p>Contents of <code class="docutils literal notranslate"><span class="pre">INTERFACE_SYSTEM_INCLUDE_DIRECTORIES</span></code> may use &quot;generator
expressions&quot; with the syntax <code class="docutils literal notranslate"><span class="pre">$&lt;...&gt;</span></code>.  See the
<span class="target" id="index-0-manual:cmake-generator-expressions(7)"></span><a class="reference internal" href="../manual/cmake-generator-expressions.7.html#manual:cmake-generator-expressions(7)" title="cmake-generator-expressions(7)"><code class="xref cmake cmake-manual docutils literal notranslate"><span class="pre">cmake-generator-expressions(7)</span></code></a> manual for available expressions.
See the <span class="target" id="index-0-manual:cmake-buildsystem(7)"></span><a class="reference internal" href="../manual/cmake-buildsystem.7.html#manual:cmake-buildsystem(7)" title="cmake-buildsystem(7)"><code class="xref cmake cmake-manual docutils literal notranslate"><span class="pre">cmake-buildsystem(7)</span></code></a> manual for more on defining
buildsystem properties.</p>
</div>


            <div class="clearer"></div>
          </div>
        </div>
      </div>
      <div class="sphinxsidebar" role="navigation" aria-label="main navigation">
        <div class="sphinxsidebarwrapper">
  <h4>Previous topic</h4>
  <p class="topless"><a href="INTERFACE_SOURCES.html"
                        title="previous chapter">INTERFACE_SOURCES</a></p>
  <h4>Next topic</h4>
  <p class="topless"><a href="INTERPROCEDURAL_OPTIMIZATION.html"
                        title="next chapter">INTERPROCEDURAL_OPTIMIZATION</a></p>
  <div role="note" aria-label="source link">
    <h3>This Page</h3>
    <ul class="this-page-menu">
      <li><a href="../_sources/prop_tgt/INTERFACE_SYSTEM_INCLUDE_DIRECTORIES.rst.txt"
            rel="nofollow">Show Source</a></li>
    </ul>
   </div>
<div id="searchbox" style="display: none" role="search">
  <h3 id="searchlabel">Quick search</h3>
    <div class="searchformwrapper">
    <form class="search" action="../search.html" method="get">
      <input type="text" name="q" aria-labelledby="searchlabel" autocomplete="off" autocorrect="off" autocapitalize="off" spellcheck="false"/>
      <input type="submit" value="Go" />
    </form>
    </div>
</div>
<script>$('#searchbox').show(0);</script>
        </div>
      </div>
      <div class="clearer"></div>
    </div>
    <div class="related" role="navigation" aria-label="related navigation">
      <h3>Navigation</h3>
      <ul>
        <li class="right" style="margin-right: 10px">
          <a href="../genindex.html" title="General Index"
             >index</a></li>
        <li class="right" >
          <a href="INTERPROCEDURAL_OPTIMIZATION.html" title="INTERPROCEDURAL_OPTIMIZATION"
             >next</a> |</li>
        <li class="right" >
          <a href="INTERFACE_SOURCES.html" title="INTERFACE_SOURCES"
             >previous</a> |</li>
  <li>
    <img src="../_static/cmake-logo-16.png" alt=""
         style="vertical-align: middle; margin-top: -2px" />
  </li>
  <li>
    <a href="https://cmake.org/">CMake</a> &#187;
  </li>
  <li>
    <a href="../index.html">3.23.1 Documentation</a> &#187;
  </li>

          <li class="nav-item nav-item-1"><a href="../manual/cmake-properties.7.html" >cmake-properties(7)</a> &#187;</li>
        <li class="nav-item nav-item-this"><a href="">INTERFACE_SYSTEM_INCLUDE_DIRECTORIES</a></li> 
      </ul>
    </div>

    <div class="footer" role="contentinfo">
        &#169; Copyright 2000-2022 Kitware, Inc. and Contributors.
      Created using <a href="https://www.sphinx-doc.org/">Sphinx</a> 4.1.2.
    </div>
  </body>
</html>