iostream与iostream.h的区别
c++ IOStream
c语言的标准输入输出库是stdio.h是一个函数库而不是类库。
其中包括了我们最常使用的scanf printf都是一些独立的全局函数,因为C语言是不支持类的。
c++的标准输入输出库iostream是一个类库,以类的形式组织,使用该库中的类要先引用命名空间:using nam espace std;最常使用的是cin和cout,这两个都是对象,cin是istream类的对象,cout是ostream类的对象,而输入的cin>>与输出时的cout<<中的左移<<与右移>>分别是istream类与ostream类的操作符重载。
iostream库里面创建了3个标准流对象:1cin表示标准输入的istream对象,cin可以使我们从设备读取数据。
2cout表示标准输出的ostream对象,cout可以使我们向设备写入数据。
3cerr表示标准错误的ostream对象,cerr是导出程序错误消息的地方,只能向屏幕设备写数据。
标准的流对象都有默认的设备:cout<<data;cout默认的设备是显示器缓冲区。
cin>>data;cin默认的设备是键盘缓冲区。
iostream库由以下几个库组成:fstream,iom ainip,ios,iosfwd,iostream,istream,ostream, sstream,stream buf,strstream。
istream用来访问操作系统的输入流,ostream访问操作系统的输出流,iostream同时继承了这两个类。
在ostream类中,重载了许多的左移<<操作符,对每种基本数据类型都做了重载,比如&ostream operator<<(ostream&tem p,int source);&ostream operator<<(ostream&tem p,char source);&ostream operator<<(ostream&tem p,char*source);由于以上重载返回的数据类型都是ostream的引用,ostream又可以作为左值,所以可以实现iostream库不仅支持终端设备的输入输出,还支持文件的输入输出,和文件有关的输入输出类声明在fstream头文件中,有三个类负责文件的输入输出1)ifstream类:从istream类派生。
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()等函数。
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>。
c++头文件iostream与iostream.h的区别
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++的新手。
当初我是菜鸟的时候也问过类似的问题。
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语言中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避免头文件的重定义在一个大的软件工程里面,可能会有多个文件同时包含一个头文件,当这些文件编译链接成一个可执行文件时,就会出现大量“重定义”的错误。
在头文件中实用#ifndef #define #endif能避免头文件的重定义。
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++编译器去做。
编译器没别的什么事好做的,⽽你却不⼀样。
fstream和ifstream详细用法
文件 I/O 在C++中比烤蛋糕简单多了。
在这篇文章里,我会详细解释ASCII和二进制文件的输入输出的每个细节,值得注意的是,所有这些都是用C++完成的。
一、ASCII 输出 为了使用下面的方法, 你必须包含头文件<fstream.h>(译者注:在标准C++中,已经使用<fstream>取代< fstream.h>,所有的C++标准头文件都是无后缀的。
)。
这是 <iostream.h>的一个扩展集, 提供有缓冲的文件输入输出操作. 事实上, <iostream.h> 已经被<fstream.h>包含了, 所以你不必包含所有这两个文件, 如果你想显式包含他们,那随便你。
我们从文件操作类的设计开始, 我会讲解如何进行ASCII I/O操作。
如果你猜是"fstream," 恭喜你答对了! 但这篇文章介绍的方法,我们分别使用"ifstream"?和 "ofstream" 来作输入输出。
如果你用过标准控制台流"cin"?和 "cout," 那现在的事情对你来说很简单。
我们现在开始讲输出部分,首先声明一个类对象。
ofstream fout; 这就可以了,不过你要打开一个文件的话, 必须像这样调用ofstream::open()。
fout.open("output.txt"); 你也可以把文件名作为构造参数来打开一个文件.ofstream fout("output.txt"); 这是我们使用的方法, 因为这样创建和打开一个文件看起来更简单. 顺便说一句, 如果你要打开的文件不存在,它会为你创建一个, 所以不用担心文件创建的问题. 现在就输出到文件,看起来和"cout"的操作很像。
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 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++输出helloworld详细注释
C++输出helloworld详细注释/* #include<iostream>#:预处理标志,后⾯跟预处理指令,include:预处理指令,包含 <iostream>:c++头⽂件,输⼊输出流这⾏的作⽤就是在预编译之前先执⾏这⾏代码。
系统提供的头⽂件⽤<>括起来#include<iostream.h>这个头⽂件是c标准的头⽂件,c++中叫⾮标准库⽂件。
using namespace std;使⽤标准命名空间。
也就是说C++当中的标准库⽂件,函数,对象啊等都存放在std空间中,作⽤:作⽤是在编写⼤程序的时候能够定义重复的变量,(标识符)当需要调⽤标准空间中的对象,函数的时候调⽤⽅法:std::cout std::cin std::endl;需要加双冒号#include<iostream> #include<iostream.h>的区别:使⽤#include<iostream>的时候,需要使⽤using namespace std;⽽#include<iostream.h>不需要*/#include <iostream>//using std::cout; //使⽤std空间中cout对象。
::调⽤的意思//using std::endl;int main(void){//cout<<"hello world"<<endl;std::cout<<"hello world"<<std::endl;return 0;}/*#include<iostream>using namespace std;int main(void){cout<<"hello world"<<endl;return 0;}#include<iostream.h>int main(void){cout<<"hello world"<<endl;return 0;}*///重命名问题#include<iostream>namespace a{int b=5;}namespace c{int b=99;}int main(void){int b=-77;std::cout<<b<<std::endl;std::cout<<a::b<<std::endl;std::cout<<c::b<<std::endl;return0;}。
C++输入输出流--iostream详解
C++输⼊输出流--iostream详解C++输⼊输出流包含在头⽂件<iostream>中,流的定义如下:通过设备驱动程序与键盘、屏幕、⽂件、打印机等进⾏交互, iostream 类提供与之交互的⽅法。
输出流:输出流的对象是字节⽬标,三个重要的输出流类是ostream、ofstream和ostringsream。
Ostream派⽣于basic_ostream⽀持预定义的流对象⼜:cout标准输出cerr标准错误输出,不经过缓冲clog类似cerr,使⽤缓冲注:缓冲是指将所有输出集中存放,然后⼀次性显⽰在屏幕上,避免多次刷屏。
格式控制输出宽度:输出宽度可以采⽤<iostream>中⾃带的width()函数,或者使⽤< iomanip >中的setw, setw 和宽度均不截断值。
使⽤width()函数代码如下:1 #include "stdafx.h"2 #include <iostream>3using namespace std;456int _tmain(int argc, _TCHAR* argv[])7 {8double values[] = { 1.23, 35.36, 653.7, 4358.24 };9for (int i = 0; i < 4; i++)10 {11 cout.width(10);12 cout << values[i] << '\n';13 }14 getchar();15return0;16 }使⽤setw()函数1 #include "stdafx.h"2 #include <iostream>3 #include <iomanip>4using namespace std;56int _tmain(int argc, _TCHAR* argv[])7 {8double values[] = { 1.23, 35.36, 653.7, 4358.24 };9for (int i = 0; i < 4; i++)10 {11//cout.width(10);12 cout << setw(10) << values[i] << '\n';13 }14 getchar();15return0;16 }程序运⾏结果:宽度设置设置宽度后,cout默认空⽩填充,如果需要填充某个字符,可采⽤fill()或setfill()函数。
第6章-程序结构
一 、<iostream>和<iostream.h>格式不一样 前者 没有后缀,实际上,在你的编译器include文件夹里面可以 看到,二者是两个文件,打开文件就会发现,里面的代码是 不一样的。 后缀为.h的头文件c++标准已经明确提出不支 持了,早些的实现将标准库功能定义在全局空间里,声明在 带.h后缀的头文件里。c++标准为了和C区别开,也为了正 确使用命名空间,规定头文件不使用后缀.h。 因 此,当使 用<iostream.h>时,相当于在c中调用库函数,使用的是全 局命名空间,也就是早期的c++实现;当使用< iostream> 的时候,该头文件没有定义全局命名空间,必须使用 namespace std;这样才能正确使用cout。
静态函数有两个效果:1、它允许其他源文件建立并使用同名的函数, 而不相互冲突,在大的编程项目中是一个优势。2、声明为静态的函数不能 被其他源文件所调用,因为得不到它的名字。
【 6.3 作用域】
作用域是标识符在程序中有效地范围,标识符的引入与声明有关,作用 于开始于标识符的声明处。 C++有四种作用域的范围: 1、局部作用域 2、函数作用域 3、函数原型作用域 4、文件作用域
本章介绍C++的程序结构。所有的C++程序都是由一个或多个函数构成的。 一个C++程序可以由一个或多个包含若干函数定义的源文件组成。C++编 译器和链接器把构成一个程序的若干源文件有机地联络在一起,最终产生 可执行程序。
一般具有应用价值的程序由多个源文件组成。其中只有一个源文件具有 main( )函数,其他的文件不能含有主函数。
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、什么是预编译,何时需要预编译:总是使用不经常改动的大型代码体。
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;。
头文件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”名字空间中。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
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关键字。
using std::cout;
using std::endl;
以上程序可以写成
cout << std::hex << 3.4 << endl;
3、最方便的就是使用using namespace std;
例如:
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
这样命名空间std内定义的所有标识符都有效(曝光)。
就好像它们被声明为全局变量一样。
那么以上语句可以如下写:
cout << hex << 3.4 << endl;
因为标准库非常的庞大,所以程序员在选择的类的名称或函数名时就很有可能和标准库中的某个名字相同。
所以为了避免这种情况所造成的名字冲突,就把标准库中的一切都放在名字空间std中。
但这又会带来了一个新问题。
无数原有的C++代码都依赖于使用了多年的伪标准库中的功能,他们都是在全局空间下的。
所以就有了<iostream.h>和<iostream>等等这样的头文件,一个是为了兼容以前的C++代码,一个是为了支持新的标准。
命名空间std封装的是标准程序库的名称,标准程序库为了和以前的头文件区别,一般不加".h"。