C++博客 :: 首页 :: 联系 :: 聚合  :: 管理
  117 Posts :: 2 Stories :: 61 Comments :: 0 Trackbacks

常用链接

留言簿(8)

搜索

  •  

最新评论

阅读排行榜

评论排行榜


第一个程序:
      这个程序不是很好的,运行的时候出现的一些问题,关于问题的原因注释有阐述。第二个程序是第一个程序的修改版。第一个程序的代码如下:

strngbad.h文件的代码:
#include <iostream>
#ifndef STRNGBAD_H_
#define STRNGBAD_H_

/* 这个StringBad类中的问题是由自动定义的隐式成员函数引起的,这种函数的行为与类设计不符。
 * StringBad类中的问题是由隐式复制构造函数和隐式复制操作符引起的。
 * 隐式地址操作符返回调用对象的地址(即this指针的值)。如果没有提供任何构造函数,C++将创建
 * 默认构造函数。也就是说,编译器将提供一个不接受任何参数,也不执行任何操作的构造函数,这
 * 是因为创建对象时总是会调用构造函数。如果定义了构造函数,C++将不会定义默认构造函数。如
 * 果希望在创建对象时显式地对它进行初始化,或需要创建对象数组时,则必须显示地定义默认构造
 * 函数。这种构造函数没有任何参数,但可以使用它来设置特定的值。带参数的构造函数也可以是
 * 默认构造函数,只要所有参数都有默认值。
 
*/

class StringBad
{
private:
    
/* 这里使用char指针(而不是char数组)来表示姓名。这意味着类声明没有为字符串本身分配
     * 存储空间,而是在构造函数中使用new来为字符串分配空间。这避免了在类声明中预先定义
     * 字符串的长度。
     
*/

    
char * str;    //pointer to string
    int len;    //length of string
    /* 这里,将num_strings成员声明为静态存储类。静态类成员有一个特点:无论创建了多少对象,
     * 程序都只创建一个静态类副本。也就是说,类的所有对象共享一个静态成员。
     
*/

    
static int num_strings;    //number of objects
public:
    StringBad(
const char * s);    //constructor
    StringBad();    //default constructor
    ~StringBad();    //destructor
    
//friend function
    friend std::ostream & operator<<(std::ostream & os,const StringBad & st);
}
;
#endif

strngbad.cpp文件的代码
#include <cstring>
#include 
"strngbad.h"
using namespace std;
/* 下面这条语句将镜头成员num_strings的值初始化为0。不能在类声明中初始化静态成员变量。
 * 这是因为声明描述了如何分配内存,但并不分配内存。你可以使用这种格式来创建对象,从
 * 而分配和初始化内存。对于静态类成员,可以在类声明之外使用单独的语句来进行初始化。
 
*/

int StringBad::num_strings=0;

StringBad::StringBad(
const char * s)
{
    len
=strlen(s);
    str
=new char[len+1];
    strcpy(str,s);
    num_strings
++;
    cout
<<num_strings<<": \""<<str<<"\" object created\n";
}

StringBad::StringBad()
{
    len
=4;
    str
=new char[4];
    strcpy(str,
"C++");
    num_strings
++;
    cout
<<num_strings<<": \""<<str<<"\" default object created\n";
}

StringBad::
~StringBad()
{
    cout
<<"\""<<str<<"\" object deleted, ";
    
--num_strings;
    cout
<<num_strings<<" left\n";
    
/* delete语句是至关重要的。str成员指向new分配的内存。当StringBad对象过期时,str指针也将过期。
     * 但str指向的内存仍被分配,除非使用delete将其释放。删除对象可以释放对象本身占用的内存,但并
     * 不能自动释放属于对象成员的指针指向的内存。因此,必须使用析构函数。在析构函数中使用delete
     * 语句可确保对象过期,由构造函数使用new分配的内存被释放。
     
*/

    delete [] str;
}

std::ostream 
& operator<<(std::ostream & os,const StringBad & st)
{
    os
<<st.str;
    
return os;
}

vegnews.cpp文件的代码
#include <iostream>
using namespace std;
#include 
"strngbad.h"

void callme1(StringBad &);
void callme2(StringBad);

/* 输出中出现的各种非标准字符随系统而异,这些字符表明,StringBad类名副其实(是一个糟糕的类)。
 * 另一种迹象是对象计数为负。在使用较新的编译器和操作系统的机器上运行时,该程序通常会在显示
 * 有关还有-1个对象的信息之前中断,而有些这样的机器将报告通用保护错误(GPF)。GPF表明程序
 * 试图访问禁止它访问的内存单元,这是另一种糟糕的信号。
 
*/

int main()
{
    StringBad headline1(
"Celery Stalks at Midnight");
    StringBad headline2(
"Lettuce Prey");
    StringBad sports(
"Spinach Leaves Bowl for Dollars");
    
    cout
<<"headline1: "<<headline1<<endl;
    cout
<<"headline2: "<<headline2<<endl;
    cout
<<"sports: "<<sports<<endl;
    
    callme1(headline1);
    cout
<<"headline1: "<<headline1<<endl<<endl;
    
    
/* 这里callme2()按值(而不是引用)传递headline2,结果表明这是一个严重的问题!
     * 这里,将headline2作为函数参数来传递从而导致析构函数被调用。其次,虽然按
     * 值传递可以防止原始参数被修改,但实际上函数已使原始字符串无法识别,导致
     * 显示一些非标准字符(显示的具体内存取决于内存中包含的内容)。
     
*/


    
/* 出现乱码的原因在于隐式地复制构造函数是按值进行复制的。那么复制str的时候
     * 复制并不是字符串,而是一个指向字符串的指针。这通常是内存管理不善的表现。
     * 解决类设计中这种问题的方法时进行深度复制(deep copy)。也就是说,复制构造
     * 函数应当复制字符串并将副本的地址赋给str成员,而不仅仅是复制字符串地址。
     * 这样每个对象都有自己的字符串,而不是引用另一个对象的字符串,调用析构函数
     * 时都将释放不同的字符串,而不会试图去释放已经被释放的字符串。
     
*/

    callme2(headline2);
    cout
<<"headline2: "<<headline2<<endl<<endl;
    
    cout
<<"Initialize one object to another:\n";
    
/* 这是用的是哪个构造函数呢?不是默认构造函数,也不是参数为const char *的构造函数。记住,
     * 这种形式的初始化等效于下面的语句:StringBad sailor=StringBad(sports); //constructor using sports
     * 因为sports的类型为StringBad,因此相应的构造函数原型应该如下:StringBad(const StringBad &);
     * 当使用一个对象来初始化另一个对象时,编译器将自动生成上述构造函数(称为复制构造函数,因为它创建对象
     * 的一个副本)。自动生成的构造函数不知道需要更新静态变量num_strings,因此会将计数方案搞乱。实际上,
     * 这个例子说明的所有问题都是由编译器自动生成的成员函数引起的。
     
*/

    StringBad sailor
=sports;
    
    cout
<<"sailor: "<<sailor<<endl;
    cout
<<"Assign one object to another: \n";
    StringBad knot;
    knot
=headline1;
    cout
<<"knot: "<<knot<<endl;
    
    
/* 因为自动存储对象被删除的顺序与创建顺序相反。所以最先删除的3个对象是knots、sailor和sport。
     * 这里,计数变得奇怪。实际上,计数异常是一条线索。因为每个对象被构造和析构一次,因此调用
     * 构造函数的次数应当与析构函数的调用次数相同。对象计数(num_strings)递减的次数比递增次数多2,
     * 这表明使用了不将num_string递增的构造函数创建了两个对象。类定义声明并定义了两个构造函数
     * (这两个构造函数都使num_strings递增),但结果表明程序使用了3个构造函数。
     
*/

    cout
<<"End of main()\n";
    
return 0;
}

void callme1(StringBad & rsb)
{
    cout
<<"String passed by reference: \n";
    cout
<<"    "<<rsb<<"\"\n";
}

void callme2(StringBad sb)
{
    cout
<<"String passed by value: \n";
    cout
<<" \""<<sb<<"\"\n";
}

第二个程序:
      关于类的new和delete有个较为清晰的阐述。

string1.h文件的代码如下:
//string1.h -- fixed and augmented string class definition
#include <iostream>
using std::ostream;
using std::istream;

/* 如果编译器没有实现布尔类型的话,可以使用int代替bool,0代替false,1代替true。
 * 如果编译器不支持静态类常量,可以用枚举来定义CINLIM。enum{CINLIM = 90};
 
*/


#ifndef STRING1_H_
#define STRING1_H_
class String
{
private:
    
char * str;     //pointer to string
    int len;    //length of string
    static int num_strings; //number of objects
    /* 原语句是static const int CINLIM=80;但是我的vc6编译不通过,所以就改成这样的形式
     * class A
     * {   
     *        static const int a;   
     * };   
     * const int A::a = 10;
     * 只有基本数字类型(书上说的是整型,但有些编译器支持float等类型)的static const变量
     * 才可以在类体内初始化,关于static const成员变量,不同的编译器在具体实现上也有些差异
     * 定义常量只有两种方式,一是上述的,二是enum。
     
*/

    
static const int CINLIM;    // cin input limit
public:
    
// constructors and other methods
    String(const char * s); //constructor
    String(); //default constructor
    String(const String &); //copy constructor
    ~String();
    
int length()const {return len;}
    
// overloaded operator methods
    String & operator=(const String &);
    String 
& operator=(const char * s);
    
char & operator[](int i);
    
const char & operator[](int i)const;
    
// overloaded operator friends
    
// vc6对友元支持不是很好,上网查了一些资料,解决办法可查看如下网址
    
// http://www.cppblog.com/kangnixi/archive/2010/02/15/107852.html
    friend bool operator< (const String &st1,const String &st2);
    friend 
bool operator> (const String &st1,const String &st2);
    friend 
bool operator== (const String &st1,const String &st2);
    friend ostream 
& operator<< (ostream & os,const String & st);
    friend istream 
& operator>> (istream & is,String & st);
    
// static function
    static int HowMany();
}
;
#endif

string1.cpp文件的代码如下:
//string1.cpp -- String class methods
#include <cstring>
#include 
"string1.h"    //includes<iostream>
using std::cin;
using std::cout;

// initializing static class member
int String::num_strings = 0;
const int String::CINLIM=80;
// static method
int String::HowMany()
{
    
return num_strings;
}


// class methods
// 程序使用构造函数String(const char *)来创建一个临时String对象,其中包含temp中的字符串拷贝
String::String(const char * s)    //construct String from C string
{
    len 
= strlen(s);    //set size
    str = new char[len+1]; //allot storage
    strcpy(str,s);    //initialize pointer
    num_strings++;  //set object count
}


/* 这是新的默认构造函数,读者可能会问,为什么代码为:str = new char[1];而不是:str = new char;
 * 上面两种方式分配的内存量相同,区别在于前者与类析构函数兼容,而后者不兼容。析构函数中包含如下
 * 代码:delete [] str;delete[]与使用new []初始化的指针和空指针都兼容。因此对于下述代码:
 * str = new char[1];
 * str[0]='\0';
 * 可修改为:str = 0; // sets str to the null pointer
 * 对于以其他方式初始化的指针,使用delete[]时,结果将是不确定的。
 
*/

String::String()    
//default constructor
{
    len 
= 4;
    str 
= new char[1];
    str[
0]='\0';    //default string
    num_strings++;
}


String::String(
const String & st)
{
    num_strings
++;    //handle static member update
    len = st.len;    //same length
    str = new char [len+1]; //allot space
    strcpy(str,st.str); //copy string to new location
}


String::
~String()    //necessary destructor
{
    
--num_strings;    //required
    delete [] str;    //required
}


// overloaded operator methods
    
    
// assign a String to a String
String & String::operator=(const String & st)
{
    
if(this == &st)
        
return *this;
    delete [] str;
    len
=st.len;
    str
=new char[len+1];
    strcpy(str,st.str);
    
return *this;
}


    
// assign a C string to a String
    
// 下面函数为提高处理效率,这样就能够直接使用常规字符串,不用创建和删除临时对象了。
String & String::operator=(const char * s)
{
    
// 一般来说,必须释放str指向的内存,并为新字符串分配足够的内存。
    delete [] str;
    len 
=strlen(s);
    str
=new char[len+1];
    strcpy(str,s);
    
return *this;
}


    
// read-write char access for non-const String
char & String::operator[](int i)
{
    
return str[i];
}

    
    
//read-only char access for const String
const char & String::operator[](int i)const
{
    
return str[i];
}


//overloaded operator friends
/* 要实现字符串比较函数,最简单的方法是使用标准的strcmp()函数。如果按照字母顺序,
 * 第一个参数位于第二个参数之前,则该函数返回一个负值;如果两个字符串相同,则返回
 * 0;如果第一个参数位于第二个参数之后,则返回一个正值
 
*/

bool operator<(const String &st1,const String &st2)
{
    
return(strcmp(st1.str,st2.str)<0);
}

bool operator>(const String &st1,const String &st2)
{
    
return st2.str<st1.str;
}

bool operator==(const String &st1,const String &st2)
{
    
return(strcmp(st1.str,st2.str)==0);
}

    
// simple String output
ostream & operator<<(ostream & os,const String & st)
{
    os
<<st.str;
    
return os;
}

    
// quick and dirty String input
    /* 重载>>操作符提供了一种将键盘输入行读入到String对象中的简单方法。它假定输入的字符数不多于
     * String::CINLIM的字符数,并丢弃多余的字符。在if条件下,如果由于某种原因(如到达文件尾,或
     * get(char *,int)读取的是一个空行)导致输入失败,istream对象的值将置为false。
     
*/

istream 
& operator>> (istream & is,String & st)
{
    
char temp[String::CINLIM];
    
is.get(temp,String::CINLIM);
    
if(is)
        st
=temp;
    
// 上面的式子在vc6编译下,发生如下错误代码
    
// error C2678: binary '=' : no operator defined which takes a left-hand operand 
    
// of type 'const class String' (or there is no acceptable conversion)
    
// 原来是我不小心看错,将st声明为const String &类型了
    while(is && is.get()!= '\n')
        
continue;
    
return is;
}

saying1.cpp文件的代码如下:
// saying1.cpp -- using expanded String class
// compile with string1.cpp
#include <iostream>
#include 
"string1.h"
using namespace std;
const int ArSize = 10;
const int MaxLen = 81;
int main()
{
    String name;
    cout
<<"Hi, what's your name?\n>> ";
    cin
>>name;

    cout
<<name<<", please enter up to "<<ArSize<<" short sayings <empty line to quit>:\n";
    String sayings[ArSize];    
//array of objects
    char temp[MaxLen];    //temporary string storage
    int i;
    
for(i=0;i<ArSize;i++)
    
{
        
/* 较早的get(char *,int)版本在读取空行后,返回的值不为false。不过,对于这些版本来说
         * 如果读取了一个空行,则字符串中第一个字符将是一个空字符。这个范例使用了下述代码:
         * if(!cin||temp[0]=='\0')    //empty line?
         *        break;                //i not incremented
         * 如果实现遵循了最新的C++标准,则if语句中的第一个条件将检测到空行,第二个条件用于
         * 旧版本实现中检测空行。
         
*/

        cout
<<i+1<<"";
        cin.
get(temp,MaxLen);
        
while(cin && cin.get()!='\n')
            
continue;
        
if(!cin || temp[0== '\0')    // empty line
            break;    //i not incremented
        else
            sayings[i]
=temp;    //overloaded assignment
    }

    
int total=i;    //total # of lines read

    cout
<<"Here are your sayings:\n";
    
for(i=0;i<total;i++)
        cout
<<sayings[i][0]<<""<<sayings[i]<<endl;

    
int shortest=0;
    
int first=0;
    
for(i=1;i<total;i++)
    
{
        
if(sayings[i].length()<sayings[shortest].length())
            shortest
=i;
        
if(sayings[i]<sayings[first])
            first
=i;
    }

    cout
<<"Shortest saying:\n"<<sayings[shortest]<<endl;
    cout
<<"First alphabetically:\n"<<sayings[first]<<endl;
    cout
<<"This program used "<<String::HowMany()<<" String objects. Bye.\n";

    
return 0;
}

posted on 2010-02-14 23:01 烟皑 阅读(744) 评论(0)  编辑 收藏 引用 所属分类: C++ primer plus学习笔记

只有注册用户登录后才能发表评论。
【推荐】超50万行VC++源码: 大型组态工控、电力仿真CAD与GIS源码库
网站导航: 博客园   IT新闻   BlogJava   知识库   博问   管理