c++头文件iostream与iostream.h的区别
.c和.h文件的区别
.c和.h文件的区别一个简单的问题：.c和.h文件的区别学了几个月的C语言，反而觉得越来越不懂了。
同样是子程序，可以定义在.c文件中，也可以定义在.h文件中，那这两个文件到底在用法上有什么区别呢？2楼：子程序不要定义在.h中。
函数定义要放在.c中，而.h只做声明.否则多引用几次，就会发生函数重复定义的错误。
3楼：.h只做声明，编译后不产生代码4楼：这样做目的是为了实现软件的模块化使软件结构清晰，而且也便于别人使用你写的程序纯粹用 C 语言语法的角度，你当然可以在 .h 中放任何东西，因为#include 完全等价于把 .h 文件 Ctrl-C Ctrl-V 到 .c 中.h 中应该都是一些宏定义和变量、函数声明，告诉别人你的程序“能干什么、该怎么用”.c 中是所有变量和函数的定义，告诉计算机你的程序“该怎么实现”5楼：当然，如果一个 .h 被多个 .c 包含而且 .h 中有对象（变量或函数）的定义，就会发生重复定义的错误了声明可以无穷多次，定义只能一次6楼：一般来说，一个C文件应该是一个模块如果你的程序仅仅有一个模块（仅仅一个C文件），就可以不用建立H文件了。
否则你的模块肯定不是独立的，你的模块里面的实现要被别的模块调用。
这个时候你最好生成一个头文件(H文件)，在头文件里面可以声明你的那些函数是公共的。
当别的模块包含你的头文件后，就可以使用你的公共声明了。
7楼：一个C对应一个H，这样管理起来方便比如你有一个"feed_dog.c",那么就再添加一个"feed_dog.h"：#ifndef _feed_dog_h#define _feed_dog_hextern void feed_dog(void);#endif其实在H文件里写函数也无所谓，只是不符合习惯而已。
只要按照以上的格式写，一个H文件添加多少次都无所谓，呵呵8楼：只是一种约定在编译器里面，.c和.h是没有区别的，.c和.h如何使用完全取决于程序员,不过为了你的程序以后还能看懂而且别人也能看懂,请遵守普遍的约定,这些约定前面的大虾们已经讲了很多了.这个就象汽车在马路上要靠右行使一样,是人为约定,汽车(编译器)本身并不知道自己是在靠左还是靠右行使.如果你喜欢,还可以用任意后缀命名源文件和头文件,但这样干可能会导致集成编译和调试环境罢工,你只好自己写makefile文件了.9楼：非常感谢各位大侠，不过我现在越来越糊涂了1,当一个函数要经常使用(比如有十几个C文件使用它）时，一般我都放在H文件里，并在前面加上__inline.对于__inline函数,很多C文件都可以INCLUDE这个H文件，但是它好象只能被一个H文件INCLUDE，如果有两个H文件INCLUDE它，就会出现编译错误。
stdlib.h和cstdlib的区别，stdlib.h和stdio.h的区别
stdlib.h和cstdlib的区别，stdlib.h和stdio.h的区别⼀、stdlib.h和cstdlib的区别C语⾔中是有#include <stdlib.h> 的。
这是C语⾔标准的包含库的头⽂件stdlib.h的语句。
在代码中引⽤此句后，就可以使⽤stdlib.h中的函数，⽽不会出现未声明的警告。
stdlib.h是C语⾔库头⽂件之⼀，包含了以下函数：1 字符串转换为数字的函数，包括atoi, atof, strtol等。
2 随机数函数，包括srand, rand等。
3 内存分配释放函数，如malloc,calloc,realloc,free等。
4 程序运⾏控制函数，如exit, abort等。
5 系统访问相关函数，如printenv, setenv，system等。
6 常⽤算法函数，如qsort, bsearch, abs,div等。
在C++中也可以使⽤#include <stdlib.h>，因为C++兼容了C语⾔中的操作。
不过⼀般更推荐使⽤C++风格的头⽂件，即#include <cstdlib>。
cstdlib实现了stdlib.h中的所有功能，不过是按照C++的⽅式写的，所以与C++语⾔可以更好的配合。
⼆、stdlib.h和stdio.h的区别（⼀）定位不同1、stdlib.h，是 standard library 标准库头⽂件，定位在通⽤⼯具函数。
2、stdio.h，是 standard input&output 标准输⼊输出头⽂件，定位在标准的输⼊输出⼯具函数。
（⼆）封装函数不同1、stdlib.h主要封装了malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()等函数。
2、stdio.h主要封装了getchar()、putchar()、scanf()、printf()、gets()、puts()、sprintf()等函数。
iostream与iostream.h的区别
iostream与iostream.h的区别iostream 的意思是输入输出流直接点说就是in(输入) out(输出) stream(流)取in out 的首字母与stream 合成[编辑本段]C++语言中#include<iostream>是标准的C++头文件，任何符合标准的C++开发环境都有这个头文件。
在旧的标准C++中,使用#include<iostream.h>但在新标准中,用#include<iostream>，而且在VS中编程的同时要注意要添加：using namespace std;using namespace std详解一：<iostream>和<iostream.h>是不一样，前者没有后缀，实际上，在你的编译器include文件夹里面可以看到，二者是两个文件，打开文件就会发现，里面的代码是不一样的。
后缀为.h的头文件c++标准已经明确提出不支持了，早些的实现将标准库功能定义在全局空间里，声明在带.h后缀的头文件里，c++标准为了和C区别开，也为了正确使用命名空间，规定头文件不使用后缀.h。
因此，当使用<iostream.h>时，相当于在c中调用库函数，使用的是全局命名空间，也就是早期的c++实现；当使用<iostream>的时候，该头文件没有定义全局命名空间，必须使用namespace std；这样才能正确使用cout。
二：所谓namespace，是指标识符的各种可见范围。
C＋＋标准程序库中的所有标识符都被定义于一个名为std的namespace中。
由于namespace的概念，使用C＋＋标准程序库的任何标识符时，可以有三种选择：1、直接指定标识符。
例如std::ostream而不是ostream。
完整语句如下：std::cout << std::hex << 3.4 << std::endl;2、使用using关键字。
C++中#include包含头文件带 .h 和不带 .h 的区别
C++中#include包含头文件带.h 和不带.h 的区别？如#include <iostream> 和#include <iostream.h> 包含的东西有哪些不同？之前在写C++程序的时候只知道使用#include <iostream> 的时候，使用函数前要用using namespace std; 导入命名空间，而#include <iostream.h> 则不用，这个得看C++标准化过程为C++开发者做了哪些有意义的工作。
C++标准化过程中，其中一个环节，解决了以下问题：（1）C++增加了名称空间概念，借以将原来声明在全局空间下的标识符声明在了namespace std下。
（2）统一C++各种后缀名，如.h、.hpp、.hxx等。
标准化之前的头文件就是带后缀名的文件，标准化后的头文件就是不带后缀名的文件。
C++ 98 规定用户应使用新版头文件，对旧版本头文件不在进行强制规范，但大多数编译器厂商依然提供旧版本头文件，以求向下兼容。
也就是说带.h 的头文件是旧标准的，如果想用新的标准的头文件就不要带.h。
另外，为了和C语言兼容，C++标准化过程中，原有C语言头文件标准化后，头文件名前带个c字母，如cstdio、cstring、ctime、ctype等等。
这些头文件都可以在C:\Program Files\Microsoft Visual Studio 10.0\VC\include这个目录下找到（以VC2010为例）。
也就是说，我们如果要用C++标准化了的C语言头文件，就得作如下的转换#include <stdio.h> --> #include <cstdio>#include <stdlib.h> --> #include <cstdlib>#include <string.h> --> #include <cstring>还要提及的一点是，我在看C++标准库的时候，看到一个特殊情况<memory.h> 和<memory>，这两个头文件是完全不同的，因为我发现<memory.h>头文件件包含了<mem.h>；而<memory> 包含<memory.stl>。
头文件string与string.h的区别
头⽂件string与string.h的区别在C++中，#include<iostream>与#include<iostream.h>的区别，前者要使⽤更新的编译器（其实⼤部分编译器多⽐较前卫了，出了有些搞嵌⼊式的⽤变态的编译器）。
喔，原来iostream是C++的头⽂件，iostream.h是C的头⽂件，即标准的C++头⽂件没有.h扩展名，将以前的C的头⽂件转化为C++的头⽂件后，有时加上c的前缀表⽰来⾃于c，例如cmath就是由math.h变来的。
using namespace std //使⽤名字空间（使⽤所有）using namespace std::cout//只使⽤cout如不⽤using，则在代码前可以⽤sdt::cout<<表⽰使⽤的是std中的cout。
#include<iostream.h>//必须要加上.hvoid main(){cout<<"Right?"<<endl;}#include<string>#include<iostream>//此处必须去掉.husingnamespace std ;void main(){string s;getline(cin,s);cout<<"Right?"<<endl;}相关解析：iostream.h⾥⾯定义的所有类以及对象都是在全局空间⾥，所以你可以直接⽤cout但在iostream⾥⾯，它所定义的东西都在名字空间std⾥⾯，所以你必须加上using namespace std才能使⽤cout⼀般⼀个C++的⽼的带“.h”扩展名的库⽂件，⽐如iostream.h，在新标准后的标准库中都有⼀个不带“.h”扩展名的相对应，区别除了后者的好多改进之外，还有⼀点就是后者的东东都塞进了“std”名字空间中。
c语言“h”和〈h〉
c语言“h”和〈h〉在C语言中，我们可以使用两种不同的方式引用头文件：使用引号（"")和尖括号（<>）。
下面将详细讨论这两种引用头文件的区别和使用方法。
1. 使用引号（""）引用头文件：以引号括起来的头文件引用表示该头文件是在当前目录或在用户指定的路径中查找。
通常，这种方式用于引用自己编写的头文件。
示例代码如下：```#include "file.h"```上述代码将在当前目录中查找名为 file.h 的头文件并引用它。
如果找不到该文件，则编译器会报错。
2. 使用尖括号（<>）引用头文件：以尖括号括起来的头文件引用表示该头文件是在系统路径中查找。
这种方式通常用于引用标准库或第三方库提供的头文件。
示例代码如下：``````上述代码将在系统路径中查找名为stdio.h 的头文件并引用它。
编译器会按照默认搜索路径来查找该头文件。
尖括号引用头文件时，编译器通常会搜索以下几个默认的系统路径（具体路径根据系统和编译器而定）：- 系统标准库路径- 环境变量中指定的路径- 编译器默认的路径在实际开发中，我们需要根据实际情况选择适合的引用方式。
下面列出了两种引用方式的一些适用场景：- 当我们编写的程序需要引用自己编写的头文件时，应该使用引号引用方式，这样可以确保编译器能够找到我们自己编写的头文件。
例如：```#include "utils.h"```- 当我们引用系统标准库或第三方库的头文件时，应该使用尖括号引用方式，因为这些头文件一般都被安装在系统指定路径下。
例如：```#include <stdlib.h>```在使用引号引用头文件时，我们还可以使用相对路径或绝对路径来指定头文件的位置。
例如，如果我们的头文件位于项目目录下的 include 文件夹中，我们可以像下面这样引用它：```#include "../include/utils.h"```这样，编译器会根据相对路径找到 utils.h 头文件并引用它。
c语言中include的用法
c语言中include的用法C语言作为一门新型高级编程语言,在计算机软件编程中具有较为广泛的应用和实现。
下面就跟你们详细介绍下c语言中include的用法，希望对你们有用。
c语言中include的用法如下：1 iostream与iostream.h的区别：#include <iostream.h> // 这个就是1998年标准化以后的标准头文件#include <iostream> // 这个就是标准化以前的头文件更本质上的区别就是iostream把标准C++库的组件放在一个名位std的namespace里面。
而相对的iostream.h则将这些标准组件放在全局空间里，同时在标准化以后旧有的C标准库也已经经过改造了。
使用前者，就需要在代码中添加语句：using namespace std;即：#include <iostream.h> ==#include <iostream>+ using namespace std;2 #include、#include<xxx.h> 与#include “xxx.h”的区别：1>，#include<xxx.h>：系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找。
2>，#include “xxx.h”：用户自定义的文件用双引号括起来，编译器首先会在用户目录下查找，然后在到C++安装目录（比如VC中可以指定和修改库文件查找路径，Unix和Linux中可以通过环境变量来设定）中查找，最后在系统文件中查找。
3 #ifndef /#define/ #endif避免头文件的重定义在一个大的软件工程里面，可能会有多个文件同时包含一个头文件，当这些文件编译链接成一个可执行文件时，就会出现大量“重定义”的错误。
C语言中的.h和.c文件
C语⾔中的.h和.c⽂件
1.h为头⽂件，.c为源⽂件，其实两者都是代码，没有实质性的区别，只是后缀不⼀样，是⼀种编程规范，主要是为了解决定义与调⽤之间的混乱。
2.h⽂件⼀般写⼀些函数声明、宏定义、结构体等内容；c⽂件是程序⽂件，内含程序的具体实现。
3.当⼀个.c⽂件需要使⽤另⼀个.c⽂件中的某个函数，此时只需要包含头⽂件，即可调⽤另⼀个.c⽂件中的函数
4.头⽂件和源⽂件区分开来有⼏点好处：⼀是头⽂件⽤于共享，只⽤⼀句#include就能包含；⼆是如果你要写库，⼜不想暴露你的源代码，可以把.c编译成.obj或是.lib发给别⼈⽤，然后把.h作为使⽤说明书。
iostream与iostream.h的区别详细解析
iostream与iostream.h的区别详细解析C++的标准类库被修订了两次，有两个标准 C92和C99,这两个库现在都在并⾏使⽤，⽤ .h 包含的是c92 ，不带 .h 的是c99的头⽂件，对于普通⽤户来说这两者没有什么区别，区别是在内部函数的具体实现上。
旧的C++头⽂件是官⽅明确反对使⽤的，但旧的C头⽂件则没有（以保持对C的兼容性）。
据说从 Visual C++ .NET 2003 开始，移除了旧的 iostream 库。
其实编译器制造商不会停⽌对客户现有软件提供⽀持，所以在可以预计的将来，旧的C++头⽂件还会嚣张⼀段时间。
如果能明⽩字符串头⽂件的使⽤，举⼀反三，其他的也差不多会⽤了:<string.h>是旧的C/C++头⽂件，对应的是基于char*的字符串处理函数；<string>是包装了std的C++头⽂件，对应的是新的strng类；<cstring>是对应旧的C头⽂件的std版本。
如果编译器都同时⽀持< iostream >和< iostream.h >，那使⽤#include < iostream >，得到的是置于名字空间std下的iostream 库的元素；如果使⽤#include < iostream.h >，得到的是置于全局空间的同样的元素。
在全局空间获取元素会导致名字冲突，⽽设计名字空间的初衷正是⽤来避免这种名字冲突的发⽣。
想象讯雷下载软件⼀样，先从服务器确定下载⽂件的⼤⼩，初始时即保存⽂件，全部填充0，多个线程下载数据直接写⼊⽂件，对⾃⼰线程负责下载的那段⽂件⽚的0进⾏改写，其中就涉及到⽂件共享写的操作vc7.1<fstream> 已经不⽀持 filebuf::sh_read等关键字，不知在vc7下若要⽤⽂件流来对⽂件进⾏⾮独占读和写操作该如何实现？⽽：vc6.0中的iostream.h <fstream.h>filebuf::sh_readfilebuf::sh_writefilebuf::sh_notefilebuf::sh_openprot⽆论⾃⼰是⽤vc6或者vc7的IDE当⽤到标准的输⼊输出和⽂件流时都是：include<iostream>include<fstream>using namespace std;A:include<iostream.h>include<fstream.h>B:include<iostream>include<fstream>如果⽤了<iostream>，则⼀定要引⼊命名空间，即"using namespace std;".如果⽤了<iostream.h>，则不那引⼊命名空间，否则会引起编译错误，提⽰找不到命名空间，例程如下：//情况⼀：使⽤<iostream>和命名空间#include <iostream>using namespace std;int main(){cout<<"<iostream> need to use namespace std!/n";return 0;}输出：<iostream> need to use namespace std!Press any key to continue//情况⼆：使⽤<iostream.h>，不引⼊命名空间#include <iostream.h>//using namespace std;int main(){cout<<"<iostream> need to use namespace std!/n";return 0;}输出：<iostream> need to use namespace std!Press any key to continue//情况三：使⽤<iostream.h>，引⼊命名空间，这时候编译出错#include <iostream.h>using namespace std;int main(){cout<<"<iostream> need to use namespace std!/n";return 0;}编译错误信息：error C2871: 'std' : does not exist or is not a namespace从 Visual C++ .NET 2003 开始，移除了旧的 iostream 库。
includestdio.h和includeiostream.h的区别
includestdio.h和includeiostream.h的区别stdio 是C标准库⾥⾯的函数库对应的基本都是标准输⼊输出等等C语⾔常⽤库的定义iostream是C++标准库的头定义，对应的基本上是C++的输⼊输出相关库定义开发C程序⽤Stdio， C++⽤Stdio/iostream 都可以。
C++时，推荐使⽤#include<iostream>using namespace std;是的，scanf和printf很轻巧，很⾼效，你也早就知道怎么⽤它们，这我承认。
但尽管他们很有⽤，事实上scanf和printf及其系列还可以做些改进。
尤其是，他们不是类型安全的，⽽且没有扩展性。
因为类型安全和扩展性是C++的基⽯，所以你也要服从这⼀点。
另外，scanf/printf系列函数把要读写的变量和控制读写格式的信息分开来，就象古⽼的FORTRAN那样。
是该向五⼗年代说诀别的时候了！不必惊奇，scanf/printf的这些弱点正是操作符>>和<<的强项:int i;Rational r;// r 是个有理数...cin >> i >> r;cout << i << r;上⾯的代码要通过编译，>>和<<必须是可以处理Rational类型对象的重载函数(可能要通过隐式类型转换)。
如果没有实现这样的函数，就会出错(处理int不⽤这样做，因为它是标准⽤法)。
另外，编译器⾃⼰可以根据不同的变量类型选择操作符的不同形式，所以不必劳你去指定第⼀个要读写的对象是int⽽第⼆个是Rational。
另外，在传递读和写的对象时采⽤的语法形式相同，所以不必象scanf那样死记⼀些规定，⽐如如果没有得到指针，必须加上地址符，⽽如果已经得到了指针，⼜要确定不要加上地址符。
这些完全可以交给C++编译器去做。
编译器没别的什么事好做的，⽽你却不⼀样。
关于C语言编程中include的用法
关于C语言编程中include的用法1 iostream与iostream.h的区别：#include <iostream.h> // 这个就是1998年标准化以后的标准头文件#include <iostream> // 这个就是标准化以前的头文件更本质上的区别就是iostream把标准C++库的组件放在一个名位std的namespace里面。
而相对的iostream.h则将这些标准组件放在全局空间里，同时在标准化以后旧有的C 标准库也已经经过改造了。
使用前者，就需要在代码中添加语句：using namespace std;即：#include <iostream.h> ==#include <iostream>+ using namespace std;2 #include、#include<xxx.h> 与#include “xxx.h”的区别：1>，#include<xxx.h>：系统自带的头文件用尖括号括起来，这样编译器会在系统文件目录下查找。
2>，#include “xxx.h”：用户自定义的文件用双引号括起来，编译器首先会在用户目录下查找，然后在到C++安装目录（比如VC中可以指定和修改库文件查找路径，Unix和Linux 中可以通过环境变量来设定）中查找，最后在系统文件中查找。
3 #ifndef /#define/ #endif避免头文件的重定义在一个大的软件工程里面，可能会有多个文件同时包含一个头文件，当这些文件编译链接成一个可执行文件时，就会出现大量“重定义”的错误。
在头文件中实用#ifndef #define#endif能避免头文件的重定义。
方法：例如要编写头文件test.h在头文件开头写上两行：#ifndef _TEST_H#define _TEST_H//一般是文件名的大写头文件结尾写上一行：#endif这样一个工程文件里同时包含两个test.h时，就不会出现重定义的错误了。
C++中#includexxx.h和#includexxx.h的区别（尖括号和双引号的区别）
C++中#includexxx.h和#includexxx.h的区别（尖括号和双引号
的区别）
第⼀种⽅式：采⽤< >⽅式，表⽰让编译器在编译器的预设标准路径下去搜索相应的头⽂件，如果找不到则报错。
例如：VS2015的安装⽬录\Microsoft Visual Studio 14.0\VC\include下⾯就包含了标准库的头⽂件。
第⼆种⽅式：采⽤" "⽅式，表⽰先在⼯程所在路径下搜索，如果失败，再到系统标准路径下搜索。
所以，特别要注意的是，如果是标准库头⽂件，那么既可以采⽤<>的⽅式，⼜可以采⽤" "的⽅式，⽽⽤户⾃定义的头⽂件只能采⽤" "的⽅式。
例如，如下这种⽅式是正确的：
#include <iostream> 效率较⾼
#include "iostream" 效率较低
如下这种⽅式是不正确的：
#include "diy.h" 是我们⾃⼰创建的头⽂件
试试看：
如果包含头⽂件时写作如#include <iostream>，但是没有using namespace std;，即没有使⽤std名字空间，能否正常实现输⼊输出功能？
结论：如果按照这样的写法，必须要使⽤std名字空间。
[转]fatalerror：iostream.h：Nosuchfileordirectory
![[转]fatalerror：iostream.h：Nosuchfileordirectory](https://img.taocdn.com/s3/m/618efcf8846a561252d380eb6294dd88d0d23deb.png)
[转]fatalerror：iostream.h：Nosuchfileordirectory iostream.h是⾮标准头⽂件，iostream是标准头⽂件形式。
iostream.h时代没有名词空间，即所有库函数包括头⽂
件iostream.h都声明在全局域。
为了体现结构层次，c++标准委员会引⼊了名词空间这⼀概念，并把所有库函数声
明由全局域改到了名词空间std。
故⽽，
⽬前这两种头⽂件等价：
#include<iostream.h>
和
#include <iostream>
using namespace std;
（因为iostream声明在std中，故⽽要加上这句，除⾮你不⽤库函数，否则错误）; 很多编译器都同时⽀持这两种头⽂件形式，更好的当然是标准头⽂件。
⾄于为什么不废除⾮标准头⽂件，⼤概
是为了兼容以前的代码吧。
还有⼀点在标准c++中，所有库函数都没有.h后缀了，如果是c语⾔的库函数，则去掉后缀，并在开头加上⼀个c （如，c++的string.h变为string，c语⾔的stdio.h,变为cstdio，c语⾔的string.h变为cstring等等）。
reference:。
C++中的using的作用,typedef与#define的区别
C++中的using 的作⽤,typedef 与#define 的区别我们⽤到的库函数基本上都属于命名空间std的，在程序使⽤的过程中要显⽰的将这⼀点标⽰出来，如std::cout。
这个⽅法⽐较烦琐，⽽我们都知道使⽤using声明则更⽅便更安全。
2、命令空间的using 声明我们在书写模块功能时，为了防⽌命名冲突会对模块取命名空间防⽌命名冲突会对模块取命名空间，这样⼦在使⽤时就需要指定是哪个命名空间，使⽤using声明，则后⾯使⽤就⽆须前缀了。
例如：using std::cin; //using 声明，当我们使⽤cin 时，从命名空间std 中获取它int main(){ int i;cin >> i; //正确：cin 和std::cin 含义相同cout << i; //错误：没有对应的using 声明，必须使⽤完整的名字return 0;}需要注意的是每个名字需要独⽴的using声明。
例如：using std::cin; //必须每⼀个都有独⽴的using 声明using std::cout; using std::endl; //写在同⼀⾏也需要独⽴声明位于头⽂件的代码⼀般来说不应该使⽤using声明。
因为头⽂件的内容会拷贝到所有引⽤它的⽂件中去，如果头⽂件⾥有某个using声明，那么每个使⽤了该头⽂件的⽂件就都会有这个声明，有可能产⽣名字冲突。
3、在⼦类中引⽤基类成员在⼦类中对基类成员进⾏声明，可恢复恢复基类的防控级别。
有三点规则：1. 在基类中的private成员，不能在派⽣类中任何地⽅⽤using声明。
2. 在基类中的protected成员，可以在派⽣类中任何地⽅⽤using声明。
当在public下声明时，在类定义体外部，可以⽤派⽣类对象访问该成员，但不能⽤基类对象访问该成员；当在protected下声明时，该成员可以被继续派⽣下去；当在private下声明时，对派⽣类定义体外部来说，该成员是派⽣类的私有成员。
C++工程的文件组织
这篇文章题目叫“浅谈VC++工程的文件组织”，其实内容不光是文件组织了，内容还还很广，我很早就想写这么篇文章，一方面是总结这几年下来的经验，另一方面就是能和别人交流交流，为了不让读者在阅读中丧失兴趣，我将在文章中加入大量生动的例子，所以这篇文章内容很散，但知识本身就是一种离散的积累之后才形成关系的连贯，难道不是吗？此文的观点并不“权威”，只是我个人的观点，欢迎来信和留言，图共同进步。
1、全局变量的声明与定义一般来说，.h文件是存放定义（Definition）的地方，而.cpp文件这是存放实现的地方（Implementation）。
简单说是这样的，不过问题来了，如果你需要一个全局变量：HWND g_hwndMain;那么应该放在.h文件中，还是在.cpp文件中？对单个变量来说，这既是声明也是定义也是实现。
按照我做法，把它放到.cpp文件中，比如放到main.cpp中去。
至于.h里，根本不需要提及它。
那如果需要在别的文件中使用到这个全局变量，那应该怎么办？那就声明一下吧：extern HWND g_hwndMain;加上了extern前缀，就变成了声明，而不是定义。
如果工程中有声明g_hwndMain，但不存在“HWND g_hwndMain”这个定义的话，在link的时候就会出错。
这里顺便提一下面试时候经常问到的一个问题，在全局变量前面加上关键字static，起到什么作用？这个问题不懂就是不懂，想不出来的。
其实很简单，就是让这个全局变量只能在这个模块（文件）中使用。
为什么？因为static，extern 两者不同同时修饰一个变量，尝试“extern static HWND g_hwndMain”，这样会导致编译错误。
“extern HWND g_hwndMain”作为一个声明，是不是就一定把它放在.h文件中，不是，应该在哪里需要使用到g_hwndMain，就在哪里声明。
大家想到了，其实使用全局变量会降低程序可读性，但开发中全局变量确实又能提供很多便利，因此用不着盲目排斥它。
C++面试题
1、以下为Windows NT 下的32 位C++程序，请计算sizeof 的值 (3)2、iostream与iostream.h的区别 (3)3、如何打印出当前源文件的文件名以及源文件的当前行号 (4)4、在C++ 程序中调用被C 编译器编译后的函数，为什么要加extern ＂C＂ (4)5、＂引用＂与多态的关系 (7)6、下面关于＂联合＂的题目的输出是什么 (7)7、请写出char *p与＂零值＂比较的if语句 (8)8、将＂引用＂作为函数返回值类型的格式、好处和需要遵守的规则 (9)9、＂引用＂与指针的区别是什么 (10)10、结构与联合有和区别？ (10)11、下面关于“联合”的题目的输出？ (10)12、已知strcpy的函数原型：char *strcpy(char *strDest, const char *strSrc)其中strDest 是目的字符串，strSrc 是源字符串。
不调用C++/C 的字符串库函数，请编写函数strcpy。
(11)13、已知String类定义如下：class String { public: String(const char *str = NULL); // 通用构造函数String(const String &another); // 拷贝构造函数~ String(); // 析构函数String & operater =(const String &rhs); // 赋值函数private: char *m_data; // 用于保存字符串}; 尝试写出类的成员函数实现。
(11)14、.h头文件中的ifndef/define/endif 的作用？ (13)17、面向对象的三个基本特征，并简单叙述之？ (15)18、重载（overload)和重写(overried，有的书也叫做“覆盖”）的区别？ (16)19、什么是预编译，何时需要预编译：总是使用不经常改动的大型代码体。
C语言常见头文件汇总
C语言常见头文件汇总C语言是一种广泛应用的编程语言，在学习和使用C语言时，我们通常会使用一些常见的头文件来调用各种函数和实现一些功能。
以下是一些常见的C语言头文件及其功能的汇总：1. stdio.h：提供了一些输入输出相关的函数，如printf、scanf等。
它是C语言中最常见的、最基础的头文件之一2. math.h：提供了数学运算相关的函数，如sin、cos、sqrt等。
3. string.h：提供了一些字符串操作相关的函数，如strcpy、strcat、strlen等。
4. stdlib.h：提供了一些通用的函数，如malloc、free、rand等。
5. ctype.h：提供了一些用于字符处理的函数，如isalnum、isalpha、tolower等。
6. stdbool.h：定义了bool类型及其取值true和false。
8. assert.h：提供了一些断言相关的函数，如assert。
9. limits.h：定义了一些与整数类型相关的宏，如INT_MAX、INT_MIN等。
10. float.h：定义了一些与浮点数类型相关的宏，如FLT_MAX、FLT_MIN等。
11. errno.h：定义了一些与错误码相关的宏和函数，如errno、perror等。
12. fcntl.h：定义了一些与文件控制相关的宏和函数，如open、close等。
13. signal.h：定义了一些与信号处理相关的宏和函数，如signal、kill等。
14. setjmp.h：定义了一些与非局部跳转相关的宏和函数，如setjmp、longjmp等。
15. locale.h：定义了一些与本地化相关的宏和函数，如setlocale、localeconv等。
16. stdarg.h：定义了一些用于可变参数函数的宏和函数，如va_list、va_start、va_arg等。
17. ctype.h：定义了一些字符分类函数，如isalpha、isdigit等。
iostream.h和stdio.h
iostream.h和stdio.h2010-02-05 08:341、要区分标准C的库和标准C++的库。
iostream是C++的库，stdio.h是标准C的库。
2、新的C++标准摒弃了.h形式的头文件，所以在vs2005里面是没有iostream.h 的头文件的3、在早期的vs版本，比如VC6.0，用的还是老版本的C++标准库，例如iostream.h，并且当时标准库也没有引入名字空间。
因此直接#include 是可以的。
但到了vs2005，使用了新的C++标准库，只能用#include 。
4、名字空间里可以包含很多东西，比如函数名、标识符、数据类型等等。
新的C++标准把标准库中的名字都放入了std名字空间，因此在#include 之后，还必须使用标准库的名字空间std，才能使用标准库里的类和函数，也就是必须using namespace std;5、对于C的标准库，例如，stdio.h，没有名字空间的概念，因此直接包含后即可使用。
6、新的C++标准库为了统一以前的C标准库，将原来c的标准库也放入了std 名字空间，并把原来的C标准库去掉了.h后缀，前面加上字母“c”，例如stdio.h 就变成了cstdio，使用时为#include ，其内容和#include 相同，但是要额外使用名字空间std，也就是using namespace std;7、因此，对于新的C++标准库，没有了.h形式的头文件，例如iostream，在包含了头文件以后，必须使用std名字空间才能使用库中的内容。
对于C标准库，有两种使用方法，一种是用老的.h形式，例如stdio.h直接包含就可以了；另一种就是用C++的统一形式，例如cstdio，和C++标准库一样，包含了以后还要加上using namespace std;才能使用。
建议采用后面统一的形式，比如你要同时使用C和C++的库，可以这样写：#include #include using namespace std;。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
iostream.h和iostream 区别
C++中新定义的方法都是有名字空间的比如cout就属于std名字空间如果include头文件的时候加上.h，默认会using namespace 否则需要自己加上using namespace XXX 对于C中已经定义的方法如printf，没有影响的iostream.h是包含输入/输出流处理的头文件,iostream就什么都不是了
但用iostream要加名词空间namespace
#include<iostream.h>
或者是
#include<iostream>
using namespace std;
二者都行
#include<iostream.h>是C语言中比较通用的
#include<iostream>
using namespace std;
是C++中比较通用的
#include <iostream.h>这样写,里面的函数都是全局函数.
不加.h的是现在C++中规定的标准，目的在于使C++代码用于移植和混合嵌入时不受扩展名.h的限制，避免因为.h而造成的额外的处理和修改
而加.h的是c语言的用法，但是在c++中也支持这种用法，主要是为了向下兼容c 的内容，我们平时尽量不用这种方法
iostream是现在C++中规定的标准，目的在于使C++代码用于移植和混合嵌入时不受扩展名.h的限制，避免因为.h而造成的额外的处理和修改。
iostream包含的基本功能和对应的旧头文件相同，但头文件的内容在名字空间std中。
（在标准化的过程中，库中有些部分的细节被修改了，所以旧头文件和新头文件中的实体不一定完全对应。
）一般情况下应该用这个头文件，而iostream.h则是老式的，以后有可能被淘汰。
经常在CSDN以及其他之类的技术论坛上问关于C++ 头文件的问题。
提出这些问题的往往就是那些刚学C++的新手。
当初我是菜鸟的时候也问过类似的问题。
现在来看看下面两个include:
#include<iostream> // 这个就是1998年标准化以后的标准头文件
#include<iostream.h> // 这个就是标准化以前的头文件
更本质上的区别就是iostream把标准C++库的组件放在一个名位std的namespace 里面。
而相对的iostream.h则将这些标准组件放在全局空间里，同时在标准化以后旧有的C 标准库也已经经过改造了。
使用前者，就需要在代码中添加语句：using namespace std;
看看下面这两个头文件
// 标准化后经过改造的C的标准库，所有的组件都放在了std中
#include<cstdio>
// 标准化以前C++中的C标准库
#include<stdio.h>
// 在看看这个头文件C标准库下基于char* 的字符处理函数库
#include<string.h>
// 在标准化以后他变成了这样
#include<cstring>
// 但是很多朋友还看见过这个字符串处理函数库，他包含了新的string class
#include<string>
经过了标准委员会如此大规模手术后，在98年以前出品的C++编译器（BC3.0，BC5.0）上能顺利通过编译的源文件，在支持新标准的编译器上可能无法顺利通过编译也就是很正常的事了。
[起因]
在回过头来看看标准程序库，这个程序库涵盖范围相当广大，提过了许许多多好用的功能。
正是因为这样标准程序库中class的名称和函数名与第三方提供的程序库中的class名或是函数名发生名字冲突的可能性大大增大。
为了避免这个问题的发生，标准委员会决定将标准程序库中每一样东西都放在namespace std中。
但是这么做同时有引来了一个新的问题。
很多C++程序代码依赖那些已经存在很多年的C++ “准”标准程序库（C++迟迟未标准化才导致这些情况的发生），例如iosteam.h,complex.h等等。
为了解决这个新出现的问题，标准化委员会决定设计一些新的头文件名，给那些穿上std 外衣的组件所使用。
把C++头文件的.h去掉，于是就有前面出现的iostream，同样C的头文件也做了相同的处理，同时在前面加上了一个字母c，以表示是C的头文件（感觉上有中种族歧视的感觉）。
同时标准化委员会声明就有的C++头文件将不再列于被支持的名单之中了，而旧有的C头文件为了满足“对C的兼容性”这个古老契约，仍然将继续存活下去。
但是，那些编译器厂商不可能去推翻他们客户的旧有编译器（也跟本不会去这么做），所以那些旧有的C++头文件仍然苟延残喘的活了下来，并不断的扰乱那些C++新兵的心智。
下面就是现在大多数C++开发工具表示头文件的组织状态：
1. 旧的C++头文件比如iostream.h，他们虽然被标准化委员会所抛弃，但由于各大厂商为了各自的商业利益仍然将继续存活下去，这些头文件的内容将不处于namespace std 中。
2. 新的C++头文件如iostream虽然提供了和旧有头文件相同的功能，但他的内容都并入了namespace std中，从而有效避免了名字污染的问题。
3. 标准C的头文件如stdio.h继续获得支持，这类文件的内容并未放在std中。
4. C函数库的技能也有对应的新式C++版本，起名称类似cstdio，这类头文件的内容也有幸穿上了std的外衣。
其实标准化以后的标准程序库的改动并不只有这些而已，很多的标准化组件都被“tamplate 化”。
其中就有元老级人物iostream。
标准程序库的问题并不是用一篇，两篇文章就可以说清楚的。
如果你像进一步的了解C++的标准程序库的话，你可以看看侯先生的《C++标准程序库》。