C++学习 之 初识头文件

声明：
            本人自学C++, 没有计算机基础，在学习的过程难免会出现理解错误，出现风马牛不相及的现象，甚至有可能会贻笑大方。 如果有幸C++大牛能够扫到本人的博客，诚心希望大牛能给予批评与指正！不胜感激！
            学习的过程分为初识、入门、进阶三个阶段。
            因为对C++没有什么了解，这样的学习设定可能也有失准确性。望兄弟们多指点。谢谢！

---

目录：
科普---- 引用头文件
1. 引用头文件的作用
2. 头文件的结构及作用
3. 常用C++头文件及描述
4. 编写头文件
回顾

科普：

• 头文件的引用方式

今天我们要开始学习头文件了。还记得我们第一天学习时写的“Hello world!” 么？还记得头文件是怎么被引入的么？就是那个"hello world!"第一行代码啊！

啥你忘记了 ？回家跪方便面去，不许碎！哈哈，就是#inlude 这一行了。iostream 就是头文件，#include 是告诉程序，我现在需要引用这个文件的内容。

昨天我也问自己，<> 是干嘛的，现在我可以告诉自己，一个大于号一个小于号，两个符号标明了符号间的内容代表的是C++标准头文件。啥？你问我难道还有不标准的么？我X，你太聪明了，你就是天才啊。日后必成大器啊。

还有另外一种标识为头文件的符号是： “”, 对的，就是双引号。但是这种引用头文件的方式，并不能说不标准 ，那两人者的区别在哪里呢？一会儿我们会说到。

也就是说引用头文件有两种写法：

#include 

#include "iostream"

那这两种写法有什么区别呢？区别可大了！

前者告诉程序，你要C++安装路径中库头文件默认存储路径下去找头文件，比如 我环境里就是/usr/inlude/C++/4.8 这个路径里查找。而后者，则告诉程序去源代码的相对路径去找。 ，你可别问我啥叫相对路径啊～不理你，你逗我玩儿。

我们一起来了解头文件吧。

 

1. 引用头文件的作用

   在了解头文件前，我们先了解下调用头文件有什么作用吧。

   为了了解调用头文件的作用，先来看下istream 头文件的内容，为啥不直接看iostream呢？为啥啊～这怎么说呢，你难住我了。。。因为iostream只不过是把istream和ostream封装了下，这么说可以么？其实不完全正确的。大牛们勿喷，我觉得在初学C++的时候，这样理解是最容易理解的。

   关于iostream标准库介绍比较详细的可以看http://www.cppblog.com/yuqilin1228/archive/2010/03/26/110620.html

   我还没有能力理解那么深入。。嘿嘿，慢慢来。

   但是这不影响所了解引用头文件的作用：调用了头文件，就等于赋予了调用某些函数的权限。不好理解么？那这样吧，你把头文件想象成一个厨柜，里面有各种厨具。一个厨师学徒就是我们的源代码，大厨就是编译器。这时 厨师学徒（源代码）想要学炒菜（编译源代码），去找大厨指点（找G++编译器），大厨跟他说，第一步，你看到那个?柜（调用了头文件）没？学徒说看到了，大厨说你去那个厨柜里拿厨具（给了学徒使用厨柜里厨具的权限）。

   我个去，我要把自己绕晕了。。。。。你明白没？当然G++编译源代码的过程可能跟我描述的过程不一样啊，这里的主要的目的也不是为了说明编译过程，而是想说明调用头文件的作用。

   那么引用头文件作用也就是：
   1. 指导编译器查寻头文件的路径  
   2. 给源代码使用库文件内容的权限
   

2. 头文件的结构及作用

   我们知道调用头文件，便有了使用头文件中的函数的权限。那么头文件本身是用来干嘛的呢？通过查看头文件的内容，我们会发现头文件本身只进行声明或者定义函数、类结构、数据接口等。
   那我们先来看看头文件吧。
   
   想要查看头文件，我们首先应该知道C++的头文件存储在哪里吧？嘿嘿，你不知道了吧？来来来，见证神奇的时刻到了：C++的标准头文件一般情况下存放在/usr/include/c++/$releaseOfC++
   比如我现在刚开始学C++，相对于我这个时代来说已经是稳定版里最高版本了，是4.8的，那我可以到/usr/include/c++/4.8 这个路径下去查看C++的标准头文件。
   
   这里为了节省篇副，我选了一个比较小的头文件：typeinfo

    // RTTI support for -*- C++ -*-
    // Copyright (C) 1994-2013 Free Software Foundation, Inc.
    //
    // This file is part of GCC.
    //
    // GCC is free software; you can redistribute it and/or modify
    // it under the terms of the GNU General Public License as published by
    // the Free Software Foundation; either version 3, or (at your option)
    // any later version.
    //
    // GCC is distributed in the hope that it will be useful,
    // but WITHOUT ANY WARRANTY; without even the implied warranty of
    // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    // GNU General Public License for more details.
    //
    // Under Section 7 of GPL version 3, you are granted additional
    // permissions described in the GCC Runtime Library Exception, version
    // 3.1, as published by the Free Software Foundation.

    // You should have received a copy of the GNU General Public License and
    // a copy of the GCC Runtime Library Exception along with this program;
    // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
    // <http://www.gnu.org/licenses/>.

    /** @file typeinfo
     * This is a Standard C++ Library header.
     */

    #ifndef _TYPEINFO
    #define _TYPEINFO

    #pragma GCC system_header

    #include 
    #if __cplusplus >= 201103L
    #include 
    #endif

    #pragma GCC visibility push(default)

    extern \"C++\" {

    namespace __cxxabiv1
    {
      class __class_type_info;
    } // namespace __cxxabiv1

    // Determine whether typeinfo names for the same type are merged (in which
    // case comparison can just compare pointers) or not (in which case strings
    // must be compared), and whether comparison is to be implemented inline or
    // not. We used to do inline pointer comparison by default if weak symbols
    // are available, but even with weak symbols sometimes names are not merged
    // when objects are loaded with RTLD_LOCAL, so now we always use strcmp by
    // default. For ABI compatibility, we do the strcmp inline if weak symbols
    // are available, and out-of-line if not. Out-of-line pointer comparison
    // is used where the object files are to be portable to multiple systems,
    // some of which may not be able to use pointer comparison, but the
    // particular system for which libstdc++ is being built can use pointer
    // comparison; in particular for most ARM EABI systems, where the ABI
    // specifies out-of-line comparison. The compiler\'s target configuration
    // can override the defaults by defining __GXX_TYPEINFO_EQUALITY_INLINE to
    // 1 or 0 to indicate whether or not comparison is inline, and
    // __GXX_MERGED_TYPEINFO_NAMES to 1 or 0 to indicate whether or not pointer
    // comparison can be used.

    #ifndef __GXX_MERGED_TYPEINFO_NAMES //预处理块
    // By default, typeinfo names are not merged.
    #define __GXX_MERGED_TYPEINFO_NAMES 0
    #endif

    // By default follow the old inline rules to avoid ABI changes.
    #ifndef __GXX_TYPEINFO_EQUALITY_INLINE
      #if !__GXX_WEAK__
        #define __GXX_TYPEINFO_EQUALITY_INLINE 0
      #else
        #define __GXX_TYPEINFO_EQUALITY_INLINE 1
      #endif
    #endif //预处理结束

    namespace std // 声明了命名空间STD
    {
      /**
       * @brief Part of RTTI.
       *
       * The @c type_info class describes type information generated by
       * an implementation.
      */
      class type_info
      {
      public:
        /** Destructor first. Being the first non-inline virtual function, this
         * controls in which translation unit the vtable is emitted. The
         * compiler makes use of that information to know where to emit
         * the runtime-mandated type_info structures in the new-abi. */
        virtual ~type_info();

        /** Returns an @e implementation-defined byte string; this is not
         * portable between */
        const char* name() const _GLIBCXX_NOEXCEPT
        { return __name[0] == \'*\' ? __name + 1 : __name; }

    #if !__GXX_TYPEINFO_EQUALITY_INLINE
        // In old abi, or when weak symbols are not supported, there can
        // be multiple instances of a type_info object for one
        // type. Uniqueness must use the _name value, not object address.
        bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
        bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
    #else
      #if !__GXX_MERGED_TYPEINFO_NAMES
        /** Returns true if @c *this precedes @c __arg in the implementation\'s
         * collation order. */
        // Even with the new abi, on systems that support dlopen
        // we can run into cases where type_info names aren\'t merged,
        // so we still need to do string comparison.
        bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return (__name[0] == \'*\' && __arg.__name[0] == \'*\')
            ? __name < __arg.__name
            : __builtin_strcmp (__name, __arg.__name) < 0; }

        bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        {
          return ((__name == __arg.__name)
                  || (__name[0] != \'*\' &&
                      __builtin_strcmp (__name, __arg.__name) == 0));
        }
      #else
        // On some targets we can rely on type_info\'s NTBS being unique,
        // and therefore address comparisons are sufficient.
        bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return __name < __arg.__name; }

        bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return __name == __arg.__name; }
      #endif
    #endif
        bool operator!=(const type_info& __arg) const _GLIBCXX_NOEXCEPT
        { return !operator==(__arg); }

    #if __cplusplus >= 201103L
        size_t hash_code() const noexcept
        {
    # if !__GXX_MERGED_TYPEINFO_NAMES
          return _Hash_bytes(name(), __builtin_strlen(name()),
                             static_cast(0xc70f6907UL));
    # else
          return reinterpret_cast(__name);
    # endif
        }
    #endif // C++11

        // Return true if this is a pointer type of some kind
        virtual bool __is_pointer_p() const;

        // Return true if this is a function type
        virtual bool __is_function_p() const;

        // Try and catch a thrown type. Store an adjusted pointer to the
        // caught type in THR_OBJ. If THR_TYPE is not a pointer type, then
        // THR_OBJ points to the thrown object. If THR_TYPE is a pointer
        // type, then THR_OBJ is the pointer itself. OUTER indicates the
        // number of outer pointers, and whether they were const
        // qualified.
        virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
                                unsigned __outer) const;

        // Internally used during catch matching
        virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
                                 void **__obj_ptr) const;

      protected:
        const char *__name;

        explicit type_info(const char *__n): __name(__n) { }

      private:
        /// Assigning type_info is not supported.
        type_info& operator=(const type_info&);
        type_info(const type_info&);
      };

      /**
       * @brief Thrown during incorrect typecasting.
       * @ingroup exceptions
       *
       * If you attempt an invalid @c dynamic_cast expression, an instance of
       * this class (or something derived from this class) is thrown. */
      class bad_cast : public exception
      {
      public:
        bad_cast() _GLIBCXX_USE_NOEXCEPT { }

        // This declaration is not useless:
        // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
        virtual ~bad_cast() _GLIBCXX_USE_NOEXCEPT;

        // See comment in eh_exception.cc.
        virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
      };

      /**
       * @brief Thrown when a NULL pointer in a @c typeid expression is used.
       * @ingroup exceptions
       */
      class bad_typeid : public exception
      {
      public:
        bad_typeid () _GLIBCXX_USE_NOEXCEPT { }

        // This declaration is not useless:
        // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
        virtual ~bad_typeid() _GLIBCXX_USE_NOEXCEPT;

        // See comment in eh_exception.cc.
        virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
      };
    } // namespace std

    } // extern \"C++\"

    #pragma GCC visibility pop

    #endif

通过这个文件，我们发现，C++的标准头文件，主要包含三个部分：
     1、头文件开始处的版权和版本声明
     2、预处理块
     3、函数和类结构声明部分等。

啥你问我，我是怎么知道有函数和类结构的？

这个么。。。嘿嘿，俺还学过shell的。对比下就猜到了。

函数的结构一般是这样的：

function_name()

{
………………
}

至于类嘛 ？class 英文翻译过来不就是类么？嘿嘿

你现在看这个头文件会不会跟我一样一头露水呢？我就纳闷了，这都啥东西啊？class是啥东西啊？namespace 又是啥东东啊？const 这又是个啥东西啊？

以前很多次，我在学东西的时候，一遇到这种情况，我就会想，XX，好难啊，这都什么东西啊，怎么一开始就让我看这么复杂、晦涩难懂的东西呢。。什么逻辑嘛！

如果你是跟我一样的，不要急，我们这里，只是想来说明头文件包含了哪些东西，弄清楚头文件本身是干嘛的，这就足够了，至于要看懂头文件的内容，我们后面一起学习，相信不久看懂它，还不如探囊取物一般？嘿嘿

都知道了头文件的组成了，还不知道头文件的作用么？就是声明函数和类结构啊～

现在，我们知道了头文件的作用（声明函数、类结构等），调用头文件的作用（使我们拥有直接调用头文件中的函数、类的权限）。眼珠子一转，我瞬间明白了，发明头文件的人，真的是熊才大略啊。

居然能想到这么牛的方式来简化我们的工作。为啥这么说呢？你想啊，函数、类结构等在头文件中声明过了，我们在编写源文件过程中，当需要使用某个函数时，如果已经在头文件中声明过，那我们直接调用就可以了啊，不用重新编写了呢！这不就简化了我们的工作么！

头文件的最大贡献，作为初学者看来，就是实现了代码的重用（在同一个源文件中可以多次使用）和共用（在不同源文件甚至不同工程中都可以共用同一个头文件）。

3. C++ 常用头文件及描述

C++都有哪些常用的头文件呢？每个头文件的具体作用又是什么呢？

参见：标准C++常用头文件及描述

4. 编写头文件

   555555……  现在怎么可能实现呢？
   通过第二步的分析我们知道头文件的主体部分包含两层内容，一层是引用另外一些头文件，这个没问题啊，不就是#inlude <头文件>么，但是另一部分是声明函数、类结构等信息啊。。。
   别灰心，别丧气，等我们学习了函数、类以后，再写头文件还不手到摛来？嗯嗯，就是这样，必须的，要循序渐进！
  等学会编写头文件了，再把连接搞过来，嗯，就这么定了！

回顾：

通过这一节的学习，我们学习了哪些东西呢？来复习一下：
1. 如何调用头文件
2. 调用头文件的作用是什么
3. 头文件本身的作用是什么
4. 使用头文件的好处是什么
5. 头文件的组成结构是怎样的
6. 关于编写头文件。。。。这个还没学会，放后面再说吧。嘿嘿

转载于:https://www.cnblogs.com/halberd-lee/p/11068738.html