当前位置：首页 > news >正文

爱站网为什么不能用了wordpress 主题安装时间

news 2025/9/29 8:05:40

爱站网为什么不能用了,wordpress 主题安装时间,北京住房与城乡建设网站,商业网站教程本章内容包括： 对类成员使用动态内存分配隐式和显式地复制构造函数隐式和显式地重载赋值操作符在构造函数中使用new所必须完成的工作使用静态类成员将布局new操作符用于对象使用指向对象的指针实现队列抽象数据类型(ADT) 动态内存和类复习范例和静态类成员首…

本章内容包括：

对类成员使用动态内存分配
隐式和显式地复制构造函数
隐式和显式地重载赋值操作符
在构造函数中使用new所必须完成的工作
使用静态类成员
将布局new操作符用于对象
使用指向对象的指针
实现队列抽象数据类型(ADT)

动态内存和类

复习范例和静态类成员

首先设计一个 StringBad类,然后设计一个功能稍强的 String类。

StringBad 和 String 类对象将包含一个字符串指针和一个表示字符串长度的值。这里使用 StingBad 和String 类，主要是为了深入了解 new、delete 和静态类成员的工作原理。因此，构造函数和析构函数调用时将显示一些消息，以便读者能够按照提示来完成操作。

对这个声明，需要注意的有两点。首先，它使用char指针(而不是char 数组)来表示姓名。这意味着类声明没有为字符串本身分配存储空间，而是在构造函数中使用new来为字符串分配空间。这避免了在类声明中预先定义字符串的长度。

strngbad.h

#include <iostream>
#ifndef STRNGBAD_H_
#define STRNGBAD_H_class StringBad
{
private:char *str;int len;static int num_strings;public:StringBad(const char *s);StringBad();~StringBad(); // destructor// friend functionfriend std::ostream &operator<<(std::ostream &os, const StringBad &st);
};
#endif

strngbad.cpp

#include <cstring>
#include "strngbad.h"
using std::cout;// initialjzing static class member
int StringBad::num_strings = 0;
// class methods
// construct StringBad fromC string
StringBad::StringBad(const char *s)
{len = std::strlen(s);str = new char[len + 1];std::strcpy(str, s);num_strings++;cout << num_strings << ": \" " << str << "\" object created\n";
}StringBad::StringBad()
{len = 4;str = new char[4];std::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;
}
std::ostream &operator<<(std::ostream &os, const StringBad &st)
{os << st.str;return os;
}

这条语句将静态成员num stings的值初始化为0。请注意，不能在类声明中初始化静态成员变量，这是因为声明描述了如何分配内存，但并不分配内存。

初始化是在方法文件中，而不是在类声明文件中进行的，这是因为类声明位于头文件中，程序可能将头文件包括在其他几个文件中。如果在头文件中进行初始化，将出现多个初始化语句副本，从而引发错误。

析构函数首先指出自己何时被调用。这部分包含了丰富的信息，但并不是必不可少的。不过，delete语句却是至关重要的。str 成员指向new 分配的内存。当StringBad 对象过期时，str 指针也将过期。但 str指向的内存仍被分配，除非使用deete 将其释放。删除对象可以释放对象本身占用的内存，但并不能自动释放属于对象成员的指针指向的内存。因此，必须使用析构函数。在析构函数中使用delete 语句可确保对象过期时，由构造函数使用 new分配的内存被释放。

vegnews.cpp

#include <iostream>
using std::cout;
#include "strngbad.h"void callme1(StringBad &); // pass by reference
void callme2(StringBad);   // pass by value
int main()
{using std::endl;StringBad headlinel("Celery stalks at Midnight");StringBad headline2("Lettuce Prey");StringBad sports("Spinach Leaves Bowl for Dollars");cout << "headlinel:" << headlinel << endl;cout << "headline2:" << headline2 << endl;cout << "sports:" << sports << endl;callme1(headlinel);cout << "headlinel:" << headlinel << endl;callme2(headline2);cout << "headline2:" << headline2 << endl;cout << "Initialize one object to another:\n";StringBad sailor = sports;cout << "sailor:" << sailor << endl;cout << "Assign one object to another:\n";StringBad knot;knot = headlinel;cout << "knot: " << knot << endl;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";
}

提前中断

程序说明

callme1()按引用传递没有发生问题

callme2()按值传递发生问题

首先，将 headline2作为函数参数来传递从而导致析构函数被调用。其次，虽然按值传递可以防止原始参数被修改，但实际上函数已使原始字符串无法识别，导致显示一些非标准字符(显示的具体内存取决于内存中包含的内容)。

当您使用一个对象来初始化另一个对象时，编译器将自动生成上述构造函数(称为复制构造函数，因为它创建对象的一个副本)。自动生成的构造函数不知道需要更新静态变量num_strings，因此会将计数方案搞乱。实际上，这个例子说明的所有问题都是由编译器自动生成的成员函数引起的，下面介绍这主题。

除去所有赋值操作，结果显示正常。

隐式成员函数

StringBad 类中的问题是由自动定义的隐式成员函数引起的,这种函数的行为与类设计不符。

具体来说C++自动提供了下面这些成员函数:

默认构造函数，如果没有定义构造函数
复制构造函数，如果没有定义
赋值操作符，如果没有定义
默认析构函数，如果没有定义
地址操作符，如果没有定义

更准确地说，编译器将生成上述最后4个函数的定义---如果程序使用对象的方式要求这样做。例如，如果您将:个对象赋给另一个对象，编译器将提供赋值操作符的定义。

结果表明，StringBad 类中的问题是由隐式复制构造函数和隐式赋值操作符引起的。

默认构造函数

复制构造函数

复制构造函数的问题

注意：

使用显式复制构造函数

解决类设计中这种问题的方法是进行深度复制(deepcopy)。

复制构造函数应当复制字符串并将副本的地址赋给s成员，而不仅仅是复制字符串地址。这样每个对象都有自己的字符串，而不是引用另一个对象的字符串。

调用析构函数时都将释放不同的字符串，而不会试图去释放已经被释放的字符串。

可以这样编写Sting的复制构造函数:

必须定义复制构造函数的原因在于，
一些类成员是使用new初始化的、指向数据的指针，而不是数据本身。

赋值操作符

C++允许类对象赋值，这是通过自动为类重载赋值操作符实现的。
这种操作符的原型如下:

赋值的问题

解决赋值的问题

对于由于默认赋值操作符不合适而导致的问题，解决办法是提供赋值操作符(进行深度复制)定义其实现与复制构造函数相似，但也有一些差别

代码首先检查自我复制，这是通过查看赋值操作符右边的地址(&s)是否与接收对象(this)的地址相同来完成的。如果相同，程序将返回*this，然后结束。

如果地址不同，函数将释放 str指向的内存，这是因为稍后将把一个新字符串的地址赋给 str。如果不首先使用 delete操作符，则上述字符串将保留在内存中。由于程序中不再包含指向该字符串的指针，因此这些内存被浪费掉。

改进后的新String类

头文件

// string1.h -- fixed and augmented string class definition
#include <iostream>
using std::istream;
using std::ostream;
#ifndef STRINGl_H_
#define STRINGI_H_
class String
{
private:char *str;int len;// pointer to string// length of stringstatic int num_strings;       // number of objectsstatic const int CINLIM = 80; // cin input limit
public:// constructors and other methodsString(const char *s);  // constructorString();               //.default constructorString(const String &); // copy constructor~String();// destructorint length() const { return len; }// overloaded operator methodsString &operator=(const String &);String &operator=(const char *);char &operator[](int i);const char &operator[](int i) const;// overloaded operator friendsfriend bool operator<(const String &st, const String &st2);friend bool operator>(const String &stl, const String &st2);friend bool operator==(const String &st, const String &st2);friend ostream &operator<<(ostream &os, const String &st);friend istream &operator>>(istream &is, String &st); // static functionstatic int HowMany();
};#endif

方法文件

string1.cpp

// stringl.cppString class methods
#include <cstring>
#include "string1.h" //includes <iostream>
using std::cin;
using std::cout;int String::num_strings = 0;
// static method
int String::HowMany()
{return num_strings;
}
// class methods
String::String(const char *s) // construct String fromC string
{len = std::strlen(s);// set size// allot storagestr = new char[len + 1];std::strcpy(str, s);num_strings++;
}String::String()
{len = 4;str = new char[1];str[0] = '\0';// default stringnum_strings++;
}String::String(const String &st)
{num_strings++;len = st.len;str = new char[len + 1];std::strcpy(str, st.str);
}String::~String()
{--num_strings;delete[] str;
}String &String::operator=(const String &st)
{if (this == &st)return *this;delete[] str;len = st.len;str = new char[len + 1];std::strcpy(str, st.str);return *this;
}
// assign aC string to a string
String &String::operator=(const char *s)
{delete[] str;len = std::strlen(s);str = new char[len + 1];std::strcpy(str, s);return *this;
}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
bool operator<(const String &st1, const String &st2)
{return (std::strcmp(st1.str, st2.str) < 0);
}
bool operator>(const String &stl, const String &st2)
{return st2.str < stl.str;
}
bool operator==(const String &stl, const String &st2)
{return (std::strcmp(stl.str, st2.str) == 0);
}// simple String output
ostream &operator<<(ostream &os, const String &st)
{os << st.str;return os;
}// quick and dirty string input
istream &operator>>(istream &is, String &st)
{char temp[String::CINLIM];is.get(temp, String::CINLIM);if (is)st = temp;while (is && is.get() != '\n')continue;return is;
}

程序文件

#include <iostream>
#include "string1.h"
const int ArSize = 10;
const int MaxLen = 81;
int main()
{using std::cin;using std::cout;using std::endl;String name;cout << "Hi,what's your name?\n>>";cin >> name;cout << name << ",please enter upto " << ArSize<< "short sayings <empty line to quit>:\n";String sayings[ArSize]; // array of objectschar temp[MaxLen];      // temporary string storageint i;for (i = 0; i < ArSize; i++){cout << i + 1 << ": ";cin.get(temp, MaxLen);while (cin && cin.get() != '\n')continue;if (!cin || temp[0] == '\0') // empty linebreak;                   // i not incrementedelsesayings[i] = temp; // overloaded assignment}int total = i;// total # of lines readcout << "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;
}

运行结果

在构造函数中使用new时应注意的事项

有关返回对象的说明

返回指向const对象的引用

使用const引用的常见原因是旨在提高效率，但对于何时可以采用这种方式存在一些限制。

如果函数返回(通过调用对象的方法或将对象作为参数)传递给它的对象，可以通过传递引用来提高方法的效率。例如，假设要编写函数 Max()，它返回两个 Vector 对象中较大的一个返回对象将调用复制构造函数，而返回引用不会。

引用指向的对象应该在调用函数执行时存在。

第三，v1和v2都被声明为 const引用，因此返回类型必须为const，这样才匹配。

返回非const对象的引用

cout 能连续输出；

返回对象

返回指向对象的指针

加入指针的程序

#include <iostream>
#include "string1.h"
#include <ctime>
const int ArSize = 10;
const int MaxLen = 81;
int main()
{using namespace std;String name;cout << "Hi,what's your name?\n>>";cin >> name;cout << name << ",please enter upto " << ArSize<< "short sayings <empty line to quit>:\n";String sayings[ArSize]; // array of objectschar temp[MaxLen];      // temporary string storageint i;for (i = 0; i < ArSize; i++){cout << i + 1 << ": ";cin.get(temp, MaxLen);while (cin && cin.get() != '\n')continue;if (!cin || temp[0] == '\0') // empty linebreak;                   // i not incrementedelsesayings[i] = temp; // overloaded assignment}int total = i;// total # of lines readif (total > 0){cout << "Here are your sayings:\n";for (i = 0; i < total; i++)cout << sayings[i] << endl;String *shortest = &sayings[0];String *first = &sayings[0];for (i = 1; i < total; i++){if (sayings[i].length() < shortest->length())shortest = &sayings[i];if (sayings[i] < *first)first = &sayings[i];}cout << "shortest saying:\n"<< *shortest << endl;cout << "First alphabetically:\n"<< *first << endl;srand(time(0));int choice = rand() % total;String *favorite = new String(sayings[choice]);cout << "My favorite saying: \n " << *favorite << endl;delete favorite;}elsecout << "No much to say, eh?\n";cout << "Bye.\n";return 0;
}

析构函数的调用

如果对象是动态变量，则当执行完定义该对象的程序块时，将调用该对象的析构函数。
如果对象是静态变量(外部、静态、静态外部或来自名称空间)，则在程序结束时将调用对象的析构函数。
如果对象是用new 创建的，则仅当您显式使用 delete 删除对象时，其析构函数才会被调用。

指针和对象小结

再谈布局new操作符

#include <iostream>
#include <string>
#include <new>
using namespace std;
const int BUF = 512;
class JustTesting
{
private:string words;int number;public:JustTesting(const string &s = "Just Testing", int n = 0){words = s;number = n;cout << words << "constructed\n";}~JustTesting() { cout << words << " destroyed\n"; }void Show() const{cout << words << ", " << number << endl;}
};int main()
{char *buffer = new char[BUF];// get a block of memoryJustTesting *pc1, *pc2;// place object in bufferpc1 = new (buffer) JustTesting;pc2 = new JustTesting("Heap1", 20); // place object on heapcout << "Memory block addresses:\n"<< "buffer: " << (void *)buffer << "    heap : " << pc2 << endl;cout << " Memory contents :\n ";cout << pc1 << " : ";pc1->Show();cout << pc2 << " : ";pc2->Show();JustTesting *pc3, *pc4;pc3 = new (buffer) JustTesting("Bad Idea", 6);pc4 = new JustTesting("Heap2", 10);cout << "Memory contents:\n";cout << pc3 << ": ";pc3->Show();cout << pc4 << ": ";pc4->Show();delete pc2;delete pc4;delete[] buffer;cout << "Done\n";return 0;
}

在使用布局new操作符时存在两个问题。首先，在创建第二个对象时，布局new操作符使用一-个新对象来覆盖用于第一个对象的内存单元。显然，如果类动态地为其成员分配内存，这将引发问题。
其次,将 delete用于 pc2 和 pc4 时,将自动调用为 pc2 和 pc4 指向的对象调用析构函数;然而,将 delete[]用于 bufer 时，不会为使用布局 new 操作符创建的对象调用析构函数。

解决方法

一

二

原因在于 delete 可与常规 new 操作符配合使用，但不能与布局new操作符配合使用。

例如，指针 pc3没有收到 new 操作符返回的地址，因此 delete pc3 将导致运行阶段错误。在另一方面，指针 pc1指向的地址与 buffer 相同,但 buffer 是使用new[]初始化的,因此必须使用 delete[]而不是 delete 来释放。

即使 buffer是使用 new而不是new[]初始化的，delete pc1也将释放buffer，而不是 pc1。这是因为 new/delete 系统知道已分配的 512 字节块 buffer，但对布局new 操作符对该内存块做了何种处理一无所知。

#include <iostream>
#include <string>
#include <new>
using namespace std;
const int BUF = 512;
class JustTesting
{
private:string words;int number;public:JustTesting(const string &s = "Just Testing", int n = 0){words = s;number = n;cout << words << "constructed\n";}~JustTesting() { cout << words << " destroyed\n"; }void Show() const{cout << words << ", " << number << endl;}
};int main()
{char *buffer = new char[BUF];// get a block of memoryJustTesting *pc1, *pc2;// place object in bufferpc1 = new (buffer) JustTesting;pc2 = new JustTesting("Heap1", 20); // place object on heapcout << "Memory block addresses:\n"<< "buffer: " << (void *)buffer << "    heap : " << pc2 << endl;cout << " Memory contents :\n ";cout << pc1 << " : ";pc1->Show();cout << pc2 << " : ";pc2->Show();JustTesting *pc3, *pc4;pc3 = new (buffer + sizeof(JustTesting)) JustTesting("Bad Idea", 6);pc4 = new JustTesting("Heap2", 10);cout << "Memory contents:\n";cout << pc3 << ": ";pc3->Show();cout << pc4 << ": ";pc4->Show();delete pc2;delete pc4;pc3->~JustTesting();pc1->~JustTesting();delete[] buffer;cout << "Done\n";return 0;
}