新手-为何不包含头文件还可以用string类型

greenben 2010-01-21 05:20:53
我初学c++,遇到一个问题:在我的测试程序里,我没有包含头文件<string>,但仍然可以使用string类型的变量。然而,如果我去掉<iostream>,编译器就会提示我 “‘string’未声明”.

我认为<iostream>不应该有关于string类型的定义,而且我查看了<iostream>的内容后,也没有发现string.

根据我所学的,"using namespace std; " 仅仅是将多个类的名字打包,其中也没有string的定义。

为什么会出现这种情况呢?

我的编译环境是 ubuntu 9.1 / gcc 4.3, 不过这应该没有什么关系吧?

这是我的测试程序:

/* File name: stack.h
* Definition for the object of stack.
*/
#include <algorithm>
#include <vector>

class Stack {
public:
bool push( const string& );
bool pop( string &elem );
bool peek( string &elem );

bool empty();
bool full();

bool find(const string &elem);

unsigned int count(const string &elem);
int size() { return _stack.size(); }

private:
vector<string> _stack;
};

//为了方便阅读,我省略了具体的函数实现
//主函数如下:

/*
* File name: stack.cpp
* Description: Homework 4.1 from Essential C++
* Enhanced Stack
*/
#include <iostream> //如果注释掉这行,就会报错
using namespace std;

#include "stack.h"

int main (void)
{

Stack s;
string str;
cout << "This is a test for enhanced class Stack." << endl;
s.push("Bin");
s.push("Andy");
s.push("Will");
s.push("Ron");
cout << "The length of s is "<< s.size()<<" Now."<<endl;
cout << "S is full?"<< s.full()<<endl;
cout << "S is empty?"<< s.empty()<<endl;
s.peek(str);
cout << "Let's peek:"<< str <<endl;
s.pop(str);
cout << "Let's pop:"<< str <<endl;
cout << "The length of s is "<< s.size()<<" Now."<<endl;
s.peek(str);
cout << "Let's peek again:"<< str <<endl;
cout << "We can find Bin?"<<s.find("Bin")<<endl;
cout << "We can find Andy"<<s.find("Andy")<<endl;
cout << "Andy position "<<s.count("Andy")<<" Now."<<endl;
cout << "The length of s is "<< s.size()<<" Now."<<endl;
cout << "Say bye to this world, S."<<endl;
cout << "S is empty?"<<s.empty()<<endl;
cout << "The length of s is "<< s.size()<<" Now."<<endl;
s.pop(str);
s.pop(str);
s.pop(str);
cout << "S is empty?"<<s.empty()<<endl;
cout << "The length of s is "<< s.size()<<" Now."<<endl;

return 0;
}

...全文
2339 20 打赏 收藏 转发到动态 举报
写回复
用AI写文章
20 条回复
切换为时间正序
请发表友善的回复…
发表回复
cnpws 2010-02-28
  • 打赏
  • 举报
回复
啊,还有这回事,学习了
chenzhuolin1002 2010-01-24
  • 打赏
  • 举报
回复
[Quote=引用 4 楼 waiting4you 的回复:]
每种编译器的标准库不一样,还是把 <string>写上去比较好。
[/Quote]
lovesi3344 2010-01-23
  • 打赏
  • 举报
回复
VC6.0好像要包含
shiweifu 2010-01-23
  • 打赏
  • 举报
回复
还是用什么写什么的好
greenben 2010-01-22
  • 打赏
  • 举报
回复 3
我找到了原因。

在<iostream>中的“stringbuf”类使用到了string定义它的一个public member.

class stringbuf{
public:
string str ( ) const;
void str ( const string & s );
...
}

所以<iostream>应该要包含<string>才可以完成这个声明。

感谢各位。
greenben 2010-01-21
  • 打赏
  • 举报
回复
[Quote=引用 9 楼 gelu1040 的回复:]
string 类本来就是在iostream里面的
string.h 只是包含字符串处理函数如strcpy函数的声明
[/Quote]

你说的是C吗, 在C++里<string>里是有string类定义的。
greenben 2010-01-21
  • 打赏
  • 举报
回复
非常感写各位的意见。
我想知道从什么地方可以找到iostream里头声明了string类型呢?

这是我从www.cplusplus.com截取的定义在iostream里的类,我并没有看到有string的类型。

另问,大家一般都在什么地方查看标准库?

Elements of the iostream library (char instantitation)
Classes:
ios_base Base class with type-independent members for the standard stream classes (class)
ios Base class with type-dependent members for the standard stream classes (class)
istream Input stream (class)
ostream Output Stream (class)
iostream Input/Output Stream (class)
ifstream Input file stream class (class)
ofstream Output file stream (class)
fstream Input/output file stream class (class)
istringstream Input string stream class (class)
ostringstream Output string stream class (class)
stringstream Input/output string stream class (class)
streambuf Base buffer class for streams (class)
filebuf File stream buffer (class)
stringbuf String stream buffer (class)
tan870426 2010-01-21
  • 打赏
  • 举报
回复
iostream里面包含string
gelu1040 2010-01-21
  • 打赏
  • 举报
回复
string 类本来就是在iostream里面的
string.h 只是包含字符串处理函数如strcpy函数的声明
ProgrammerNO1 2010-01-21
  • 打赏
  • 举报
回复
[Quote=引用 5 楼 keiy 的回复:]
这个是与编译器有关,我的编译器不能用,必须要#include <string>
[/Quote]

你用的啥编译器
「已注销」 2010-01-21
  • 打赏
  • 举报
回复
<iostream>包含string , 不过LZ还是包含<string>好 , 等回过头看时一目了然
cocat 2010-01-21
  • 打赏
  • 举报
回复
恩~最好还是加上去的比较好~
柯本 2010-01-21
  • 打赏
  • 举报
回复
这个是与编译器有关,我的编译器不能用,必须要#include <string>
Waiting4you 2010-01-21
  • 打赏
  • 举报
回复
每种编译器的标准库不一样,还是把<string>写上去比较好。
macrojj 2010-01-21
  • 打赏
  • 举报
回复
真的吗
liujiaji 2010-01-21
  • 打赏
  • 举报
回复
[Quote=引用 1 楼 wuhuwy 的回复:]
Iostream中也有对String头文件的引用的,所以有Iostream后就不需要再包含Stream头文件了
[/Quote]

正解!
wuhuwy 2010-01-21
  • 打赏
  • 举报
回复
Iostream中也有对String头文件的引用的,所以有Iostream后就不需要再包含Stream头文件了
sk_sakula 2010-01-21
  • 打赏
  • 举报
回复
[Quote=引用 7 楼 lpf66fpl 的回复:]
<iostream>包含string , 不过LZ还是包含 <string>好 , 等回过头看时一目了然
[/Quote]

回答的非常好!!顶
macrojj 2010-01-21
  • 打赏
  • 举报
回复
XSTRING
C、传统 C++ #include     //设定插入点 #include      //字符处理 #include      //定义错误码 #include      //浮点数处理 #include     //文件输入/输出 #include     //参数化输入/输出 #include    //数据流输入/输出 #include     //定义各种数据类型最值常量 #include     //定义本地化函数 #include      //定义数学函数 #include      //定义输入/输出函数 #include     //定义杂项函数及内存分配函数 #include <string.h>    //字符串处理 #include    //基于数组的输入/输出 #include      //定义关于时间的函数 #include      //宽字符处理及输入/输出 #include     //宽字符分类 ////////////////////////////////////////////////////////////////////////// 标准 C++ (同上的不再注释) #include     //STL 通用算法 #include      //STL 位集容器 #include #include #include #include #include      //复数类 #include #include #include string> #include #include       //STL 双端队列容器 #include     //异常处理类 #include #include    //STL 定义运算函数(代替运算符) #include #include       //STL 线性列表容器 #include        //STL 映射容器 #include #include        //基本输入/输出支持 #include      //输入/输出系统使用的前置声明 #include #include      //基本输入流 #include      //基本输出流 #include       //STL 队列容器 #include        //STL 集合容器 #include      //基于字符串的流 #include       //STL 堆栈容器     #include     //标准异常类 #include     //底层输入/输出支持 #include <string>     //字符串类 #include      //STL 通用模板类 #include      //STL 动态数组容器 #include #include using namespace std; ////////////////////////////////////////////////////////////////////////// C99 增加 #include    //复数处理 #include     //浮点环境 #include   //整数格式转换 #include    //布尔环境 #include    //整型环境 #include    //通用类型数学宏 --------------------------------------------------------------------------------------------------------- 补充: 经常在CSDN以及其他之类的技术论坛上问关于C++ 头文件的问题。提出这些问题的往往就是那些刚学C++的新手。当初我是菜鸟的时候也问过类似的问题。 现在来看看下面两个include: #include // 这个就是1998年标准化以后的标准头文件 #include // 这个就是标准化以前的头文件 更本质上的区别就是iostream把标准C++库的组件放在一个名位std的namespace里面。而相对的iostream.h则将这些标准组件放在全局空间里,同时在标准化以后旧有的C标准库也已经经过改造了。 看看下面这两个头文件 // 标准化后经过改造的C的标准库,所有的组件都放在了std中 #include // 标准化以前C++中的C标准库 #include // 在看看这个头文件C标准库下 基于char* 的字符处理函数库 #include<string.h> // 在标准化以后他变成了这样 #includestring> // 但是很多朋友还看见过这个字符串处理函数库,他包含了新的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++标准程序库》。
主体:(一) 一、C++概述 (一) 发展历史 1980年,Bjarne Stroustrup博士开始着手创建一种模拟语言,能够具有面向对象的程序设计特色。在当时,面向对象编程还是一个比较新的理念,Stroustrup博士并不是从头开始设计新语言,而是在C语言的基础上进行创建。这就是C++语言。 1985年,C++开始在外面慢慢流行。经过多年的发展,C++已经有了多个版本。为次,ANSI和ISO的联合委员会于1989年着手为C++制定标准。1994年2月,该委员会出版了第一份非正式草案,1998年正式推出了C++的国际标准。 (二) C和C++ C++是C的超集,也可以说C是C++的子集,因为C先出现。按常理说,C++编译器能够编译任何C程序,但是C和C++还是有一些小差别。 例如C++增加了C不具有的关键字。这些关键字能作为函数和变量的标识符在C程序中使用,尽管C++包含了所有的C,但显然没有任何C++编译器能编译这样的C程序。 C程序员可以省略函数原型,而C++不可以,一个不带参数的C函数原型必须把void写出来。而C++可以使用空参数列表。 C++中new和delete是对内存分配的运算符,取代了C中的malloc和free。 标准C++中的字符串类取代了C标准C函数库头文件中的字符数组处理函数。 C++中用来做控制态输入输出的iostream类库替代了标准C中的stdio函数库。 C++中的try/catch/throw异常处理机制取代了标准C中的setjmp()和longjmp()函数。 二、关键字和变量 C++相对与C增加了一些关键字,如下: typename bool dynamic_cast mutable namespace static_cast using catch explicit new virtual operator false private template volatile const protected this wchar_t const_cast public throw friend true reinterpret_cast try bitor xor_e and_eq compl or_eq not_eq bitand 在C++中还增加了bool型变量和wchar_t型变量: 布尔型变量是有两种逻辑状态的变量,它包含两个值:真和假。如果在表达式中使用了布尔型变量,那么将根据变量值的真假而赋予整型值1或0。要把一个整型变量转换成布尔型变量,如果整型值为0,则其布尔型值为假;反之如果整型值为非0,则其布尔型值为真。布儿型变量在运行时通常用做标志,比如进行逻辑测试以改变程序流程。 #include iostream.h int main() { bool flag; flag=true; if(flag) cout<类型,wchar_t也是字符类型,但是是那些宽度超过8位的数据类型。许多外文字符集所含的数目超过256个,char字符类型无法完全囊括。wchar_t数据类型一般为16位。 标准C++的iostream类库中包括了可以支持宽字符的类和对象。用wout替代cout即可。 #include iostream.h int main() { wchar_t wc; wc='b'; wout<类型)。 三、强制类型转换 有时候,根据表达式的需要,某个数据需要被当成另外的数据类型来处理,这时,就需要强制编译器把变量或常数由声明时的类型转换成需要的类型。为此,就要使用强制类型转换说明,格式如下: int* iptr=(int*) &table; 表达式的前缀(int*)就是传统C风格的强制类型转换说明(typecast),又可称为强制转换说明(cast)。强制转换说明告诉编译器把表达式转换成指定的类型。有些情况下强制转换是禁用的,例如不能把一个结构类型转换成其他任何类型。数字类型和数字类型、指针和指针之间可以相互转换。当然,数字类型和指针类型也可以相互转换,但通常认为这样做是不安全而且也是没必要的。强制类型转换可以避免编译器的警告。 long int el=123; short i=(int) el; float m=34.56; int i=(int) m; 上面两个都是C风格的强制类型转换,C++还增加了一种转换方式,比较一下上面和下面这个书写方式的不同: long int el=123; short i=int (el); float m=34.56; int i=int (m); 使用强制类型转换的最大好处就是:禁止编译器对你故意去做的事发出警告。但是,利用强制类型转换说明使得编译器的类型检查机制失效,这不是明智的选择。通常,是不提倡进行强制类型转换的。除非不可避免,如要调用malloc()函数时要用的void型指针转换成指定类型指针。 四、标准输入输出流 在C语言中,输入输出是使用语句scanf()和printf()来实现的,而C++中是使用类来实现的。 #include iostream.h main() //C++中main()函数默认为int型,而C语言中默认为void型。 { int a; cout<>a; /*输入一个数值*/ cout<a; cout<包含一个或多个用不到的形式参数。这种情况多出现在用一个通用的函数指针调用多个函数的场合,其中有些函数不需要函数指针声明中的所有参数。看下面的例子: int fun(int x,int y) { return x*2; } 尽管这样的用法是正确的,但大多数C和C++的编译器都会给出一个警告,说参数y在程序中没有被用到。为了避免这样的警告,C++允许声明一个无名形参,以告诉编译器存在该参数,且调用者需要为其传递一个实际参数,但是函数不会用到这个参数。下面给出使用了无名参数的C++函数代码: int fun(int x,int) //注意不同点 { return x*2; } (二) 函数的默认参数 C++函数的原型中可以声明一个或多个带有默认值的参数。如果调用函数时,省略了相应的实际参数,那么编译器就会把默认值作为实际参数。可以这样来声明具有默认参数的C++函数原型: #include iostream.h void show(int=1,float=2.3,long=6); int main() { show(); show(2); show(4,5.6); show(8,12.34,50L); return 0; } void show(int first,float second,long third) { cout<类型不能完全相同,这样这些函数就可以相互区别开来。而这在C语言中是不允许的。 1.参数个数不同 #include iostream.h void a(int,int); void a(int); int main() { a(5); a(6,7); return 0; } void a(int i) { cout<a; for(int i=1;i<=10;i++) //C语言中,不允许在这里定义变量 { static int a=0; //C语言中,同一函数块,不允许有同名变量 a+=i; cout<<::a<< <size; int *array=new int[size]; for(int i=0;idt; if(dt>0 && dt<4) { const Date& bd=getdate(dt); cout<类型的C++机制。它和C语言中的结构类似,C++类支持数据抽象和面向对象的程序设计,从某种意义上说,也就是数据类型的设计和实现。 一、类的设计 1.类的声明 class 类名 { private: //私有 ... public: //公有 ... }; 2.类的成员 一般在C++类中,所有定义的变量和函数都是类的成员。如果是变量,我们就叫它数据成员如果是函数,我们就叫它成员函数。 3.类成员的可见性 private和public访问控制符决定了成员的可见性。由一个访问控制符设定的可访问状态将一直持续到下一个访问控制符出现,或者类声明的结束。私有成员仅能被同一个类中的成员函数访问,公有成员既可以被同一类中的成员函数访问,也可以被其他已经实例化的类中函数访问。当然,这也有例外的情况,这是以后要讨论的友元函数。 类中默认的数据类型是private,结构中的默认类型是public。一般情况下,变量都作为私有成员出现,函数都作为公有成员出现。 类中还有一种访问控制符protected,叫保护成员,以后再说明。 4.初始化 在声明一个类的对象时,可以用圆括号()包含一个初始化表。 看下面一个例子: #include iostream.h class Box { private: int height,width,depth; //3个私有数据成员 public: Box(int,int,int); ~Box(); int volume(); //成员函数 }; Box::Box(int ht,int wd,int dp) { height=ht; width=wd; depth=dp; } Box::~Box() { //nothing } int Box::volume() { return height*width*depth; } int main() { Box thisbox(3,4,5); //声明一个类对象并初始化 cout<类型,即使是void型都不可以。实际上构造函数默认为void型。 当一个类的对象进入作用域时,系统会为其数据成员分配足够的内存,但是系统不一定将其初始化。和内部数据类型对象一样,外部对象的数据成员总是初始化为0。局部对象不会被初始化。构造函数就是被用来进行初始化工作的。当自动类型的类对象离开其作用域时,所站用的内存将释放回系统。 看上面的例子,构造函数Box()函数接受三个整型擦黑素,并把他们赋值给立方体对象的数据成员。 如果构造函数没有参数,那么声明对象时也不需要括号。 1.使用默认参数的构造函数 当在声明类对象时,如果没有指定参数,则使用默认参数来初始化对象。 #include iostream.h class Box { private: int height,width,depth; public: Box(int ht=2,int wd=3,int dp=4) { height=ht; width=wd; depth=dp; } ~Box(); int volume() { return height*width*depth; } }; int main() { Box thisbox(3,4,5); //初始化 Box defaulbox; //使用默认参数 cout<类型遵循隐式类型转换规则。假设某个表达市中使用了一个短整型变量,而编译器根据上下文认为这儿需要是的长整型,则编译器就会根据类型转换规则自动把它转换成长整型,这种隐式转换出现在赋值、参数传递、返回值、初始化和表达式中。我们也可以为类提供相应的转换规则。 对一个类建立隐式转换规则需要构造一个转换函数,该函数作为类的成员,可以把该类的对象和其他数据类型的对象进行相互转换。声明了转换函数,就告诉了编译器,当根据句法判定需要类型转换时,就调用函数。 有两种转换函数。一种是转换构造函数;另一种是成员转换函数。需要采用哪种转换函数取决于转换的方向。 一、转换构造函数 当一个构造函数仅有一个参数,且该参数是不同于该类的一个数据类型,这样的构造函数就叫转换构造函数。转换构造函数把别的数据类型的对象转换为该类的一个对象。和其他构造函数一样,如果声明类的对象的初始化表同转换构造函数的参数表相匹配,该函数就会被调用。当在需要使用该类的地方使用了别的数据类型,便宜器就会调用转换构造函数进行转换。 #include iostream.h #include time.h #include stdio.h class Date { int mo, da, yr; public: Date(time_t); void display(); }; void Date::display() { char year[5]; if(yr<10) sprintf(year,0%d,yr); else sprintf(year,%d,yr); cout<tm_mon+1; yr=tim->tm_year; if(yr>=100) yr-=100; } int main() { time_t now=time(0); Date dt(now); dt.display(); return 0; } 本程序先调用time()函数来获取当前时间,并把它赋给time_t对象;然后程序通过调用Date类的转换构造函数来创建一个Date对象,该对象由time_t对象转换而来。time_t对象先传递给localtime()函数,然后返回一个指向tm结构(time.h文件中声明)的指针,然后构造函数把结构中的日月年的数值拷贝给Date对象的数据成员,这就完成了从time_t对象到Date对象的转换。 二、成员转换函数 成员转换函数把该类的对象转换为其他数据类型的对象。在成员转换函数的声明中要用到关键字operator。这样声明一个成员转换函数: operator aaa(); 在这个例子中,aaa就是要转换成的数据类型的说明符。这里的类型说明符可以是任何合法的C++类型,包括其他的类。如下来定义成员转换函数; Classname::operator aaa() 类名标识符是声明了该函数的类的类型说明符。上面定义的Date类并不能把该类的对象转换回time_t型变量,但可以把它转换成一个长整型值,计算从2000年1月1日到现在的天数。 #include iostream.h class Date { int mo,da,yr; public: Date(int m,int d,int y) {mo=m; da=d; yr=y;} operator int(); //声明 }; Date::operator int() //定义 { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; int days=yr-2000; days*=365; days+=(yr-2000)/4; for(int i=0;i包含年份和天数。 这个例子没有考虑闰年情况。但是在实际构造一个类时,应该考虑到所有问题的可能性。 在Date里中具有两种转换函数,这样,当需要从Date型变为CustomDate型十,可以调用成员转换函数;反之可以调用转换构造函数。 不能既在Date类中定义成员转换函数,又在CustomDate类里定义转换构造函数。那样编译器在进行转换时就不知道该调用哪一个函数,从而出错。 四、转换函数的调用 C++里调用转换函数有三种形式:第一种是隐式转换,例如编译器需要一个Date对象,而程序提供的是CustomDate对象,编译器会自动调用合适的转换函数。另外两种都是需要在程序代码中明确给出的显式转换。C++强制类型转换是一种,还有一种是显式调用转换构造函数和成员转换函数。下面的程序给出了三中转换形式: #include iostream.h class CustomDate { public: int da, yr; CustomDate(int d=0,int y=0) {da=d; yr=y;} void display() { cout<类型对象之间的相互赋值来调用转换函数,还有几种调用的可能: 参数传递 初始化 返回值 表达式语句 这些情况下,都有可能调用转换函数。 下面的程序不难理解,就不分析了。 #include iostream.h class CustomDate { public: int da, yr; CustomDate() {} CustomDate(int d,int y) { da=d; yr=y;} void display() { cout<包含了explicit修饰符。 七、表达式内部的转换 在表达式内部,如果发现某个类型和需要的不一致,就会发生错误。数字类型的转换是很简单,这里就不举例了。下面的程序是把Date对象转换成长整型值。 #include iostream.h class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } operator long(); }; Date::operator long() { static int dys[]={31,28,31,30,31,30,31,31,30,31,30,31}; long days=yr; days*=365; days+=(yr-1900)/4; //从1900年1月1日开始计算 for(int i=0;i类型,或者表达式调用了作用于某个类的重载运算符时,就会发生隐式转换。运算符重载以后再学习。 主体:(四)私有数据成员和友元 一、私有数据成员的使用 1.取值和赋值成员函数 面向对象的约定就是保证所有数据成员的私有性。一般我们都是通过公有成员函数来作为公共接口来读取私有数据成员的。某些时候,我们称这样的函数为取值和赋值函数。 取值函数的返回值和传递给赋值函数的参数不必一一匹配所有数据成员的类型。 #include iostream.h class Date { int mo, da, yr; public: Date(int m,int d,int y) { mo=m; da=d; yr=y; } int getyear() const { return yr; } void setyear(int y) { yr = y; } }; int main() { Date dt(4,1,89); cout<string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void display() const; }; Date::Date(int m,int d,int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo=m; da=d; yr=y; if(m!=0) { month=new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if(month!=0) cout<类型为void。它是类总的成员函数,在本程序红,是Date类的成员函数。它的函数名始终是operator =,参数也始终是同一个类的对象的引用。参数表示的是源对象,即赋值数据的提供者。重载函数的运算符作为目标对象的成员函数来使用。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void operator=(const Date&); void display() const; }; Date::Date(int m, int d, int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo = m; da = d; yr = y; if (m != 0) { month = new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if (month!=0) cout<包含这个参数。 当程序中调用某个对象的成员函数时,编译器会把该对象的地址加入到参数列表中,感觉上就好象函数采用了上面所示的声明,并且是用如下方式来调用的: dt.myFunc(& dt); 静态成员函数不存在this指针。 当调用某个对象的成员函数时,编译器把对象的地址传递给this指针,然后再调用该函数。因此,成员函数你对任何成员的调用实际上都隐式地使用了this指针。 1.以this指针作为返回值 使用this指针可以允许成员函数返回调用对象给调用者。前面的程序中重载赋值运算符没有返回值,因此不能用如下的形式对字符串进行赋值: a=b=c; 为了使重载的类赋值机制也能这样方便,必须让赋值函数返回赋值的结果,在这里就是目标对象。当赋值函数执行时,其返回值也恰好是this指针所指的内容。 下面的程序对前面那个程序进行了修改,让重载赋值运算符返回了一个Date对象的引用。 #include iostream.h #include string.h class Date { int mo,da,yr; char *month; public: Date(int m=0, int d=0, int y=0); ~Date(); void operator=(const Date&); void display() const; }; Date::Date(int m, int d, int y) { static char *mos[] = { January,February,March,April,May,June, July,August,September,October,November,December }; mo = m; da = d; yr = y; if (m != 0) { month = new char[strlen(mos[m-1])+1]; strcpy(month, mos[m-1]); } else month = 0; } Date::~Date() { delete [] month; } void Date::display() const { if (month!=0) cout<类型的成员,那么使用this指针会提供更多的方便。下面的程序中建立了一个类ListEntry的链表。 #include iostream.h #include string.h class ListEntry { char* listvalue; ListEntry* preventry; public: ListEntry(char*); ~ListEntry() { delete [] listvalue; } ListEntry* PrevEntry() const { return preventry; }; void display() const { cout< name; if (strncmp(name, end, 3) == 0) break; ListEntry* list = new ListEntry(name); if (prev != 0) prev->AddEntry(*list); prev = list; } while (prev != 0) { prev->display(); ListEntry* hold = prev; prev = prev->PrevEntry(); delete hold; } return 0; } 程序运行时,会提示输入一串姓名,当输入完毕后,键入end,然后程序会逆序显示刚才输入的所有姓名。 程序中ListEntry类含有一个字符串和一个指向前一个表项的指针。构造函数从对中获取内存分配给字符串,并把字符串的内容拷贝到内存,然后置链接指针为NULL。析构函数将释放字符串所占用的内存。 成员函数PrevEntry()返回指向链表前一个表项的指针。另一个成员函数显示当前的表项内容。 成员函数AddEntry(),它把this指针拷贝给参数的preventry指针,即把当前表项的地址赋值给下一个表项的链接指针,从而构造了一个链表。它并没有改变调用它的listEntry对象的内容,只是把该对象的地址赋给函数的参数所引用的那个ListEntry对象的preventry指针,尽管该函数不会修改对象的数据,但它并不是常量型。这是因为,它拷贝对象的地址this指针的内容给一个非长常量对象,而编译器回认为这个非常量对象就有可能通过拷贝得到的地址去修改当前对象的数据,因此AddEntry()函数在声明时不需要用const。 主体:(六)类对象数组和静态成员 一、类对象数组 类的对象和C++其他数据类型一样,也可以为其建立数组,数组的表示方法和结构一样。 #include iostream.h class Date { int mo,da,yr; public: Date(int m=0,int d=0, int y=0) { mo=m; da=d; yr=y;} void display() const { cout<包含初始化值的单个Date对象。接着把这个初始化的Date对象赋值给数组中第一个对象,然后显示两个数组元素中包含的日期。从输出中可以看到,第一个日期是有效日期,而第二个显示的都是0。 当声明了某个类的对象数组时,编译器会为每个元素都调用默认构造函数。 下面的程序去掉了构造函数的默认参数值,并且增加了一个默认构造函数。 #include class Date { int mo, da, yr; public: Date(); Date(int m,int d,int y) { mo=m; da=d; yr=y;} void display() const { cout <string.h class ListEntry { public: static ListEntry* firstentry; private: static ListEntry* lastentry; char* listvalue; ListEntry* nextentry; public: ListEntry(char*); ~ListEntry() { delete [] listvalue;} ListEntry* NextEntry() const { return nextentry; }; void display() const { cout<name
//以下假设你已经配置好VC6的GDI+环境 1.新建一个基于CScrollView的单文档程序, 2.在stdafx.h内添加如下代码: #ifndef ULONG_PTR #define ULONG_PTR unsigned long* #endif #include "GdiPlus.h" using namespace Gdiplus; #pragma comment(lib,"gdiplus.lib") 3.在GdiApp.h里的CGdiAppApp中加入两个成员: GdiplusStartupInput m_gdiplusStartupInput;// ULONG_PTR m_pGdiToken;// 4.在GdiApp.cpp中的CGdiAppApp构造函数CGdiAppApp()添加如下代码: GdiplusStartup(&m_pGdiToken,&m_gdiplusStartupInput,NULL);// 5.在GdiApp.h里给CGdiAppApp添加一个析构函数~CGdiAppApp(); 6.在GdiApp.cpp中添加CGdiAppApp的析构函数~CGdiAppApp(): CGdiAppApp::~CGdiAppApp()// { GdiplusShutdown(m_pGdiToken);// } 7.在GdiAppView.h的CGdiAppView中添加成员变量: Bitmap* m_pbmp; 并在GdiAppView.cpp中的GdiAppView构造函数和析构函数中添加如下代码: CGdiAppView::CGdiAppView():m_pbmp(0)// { // TODO: add construction code here } CGdiAppView::~CGdiAppView() { delete m_pbmp;// m_pbmp=0;// } 8.按Ctrl+W,在弹出的对话框里选择Message Maps选项卡 class name选择CGdiAppView Object IDs里选中ID_FILE_OPEN 然后在Message里双击COMMAND 弹出的对话框选择Ok 这时会在Member functions:里多出一条刚添加进去的消息映射函数 双击它会自动跳转进入GdiAppView.cpp中的void CGdiAppView::OnFileOpen()函数处 然后添加如下代码: void CGdiAppView::OnFileOpen() { //见源码处 } 9.为了使8处代码有用,还需要: 在GdiAppView.h里添加两个函数声明: int A2U(const char* szA,wchar_t* szU,size_t cnt);// std::wstring A2U(const char* szA);// 并#include 然后在GdiAppView.cpp里加入这两个函数的实现 10.在GdiAppView.cpp中的OnDraw函数中添加显示代码: void CGdiAppView::OnDraw(CDC* pDC) { //见源码处 } 11.结束.有问题联系hastings1986@163.com //可能你Debug版本编译不过,则打开Gdi+的头文件GdiPlusBase.h //并修改为如下(其实就加了两个重载版本的new和delete): #ifndef _GDIPLUSBASE_H #define _GDIPLUSBASE_H class GdiplusBase { public: void (operator delete)(void* in_pVoid) { DllExports::GdipFree(in_pVoid); } void* (operator new)(size_t in_size) { return DllExports::GdipAlloc(in_size); } void (operator delete[])(void* in_pVoid) { DllExports::GdipFree(in_pVoid); } void* (operator new[])(size_t in_size) { return DllExports::GdipAlloc(in_size); } //////////////////////////////// void* (operator new)(size_t in_size,

33,311

社区成员

发帖
与我相关
我的任务
社区描述
C/C++ 新手乐园
社区管理员
  • 新手乐园社区
加入社区
  • 近7日
  • 近30日
  • 至今
社区公告
暂无公告

试试用AI创作助手写篇文章吧