189 8069 5689
新type的对象应该如何被创建和销毁？：这会影响到你的class的构造函数和析构函数以及内存分配函数和释放函数的设计。
目前成都创新互联公司已为近1000家的企业提供了网站建设、域名、虚拟空间、网站改版维护、企业网站设计、安阳县网站维护等服务，公司将坚持客户导向、应用为本的策略，正道将秉承"和谐、参与、激情"的文化，与客户和合作伙伴齐心协力一起成长，共同发展。对象的初始化和对象的赋值有什么样的区别？这答案决定你的构造函数和赋值操作符的行为，以及其间的差异。很重要的是别混淆了“初始化”和“赋值”，因为它们对应不同的函数调用。
新type的对象如果被passed by value（以值传递），意味着什么？记住，copy构造函数用来定义一个type的pass-by-value该如何实现。
什么是新type的“合法值”？对于class的成员变量而言，通常只有某些数值集是有效的。那些数值决定了你的class必须维护的约束条件，也就决定了你的成员函数必须进行的错误检查工作，它也影响函数抛出的异常、以及函数异常明细列。
你的新type需要配合某个继承体系吗？如果你继承自某些既有的classes，你就受到那些classes的设计的束缚，特别是受到“它们的函数是virtual或non-virtual”的影响。如果你允许其他classes继承你的class，那会影响你所声明的函数--尤其是析构函数，是否为virtual。
你的新type需要什么样的转换？如何你允许类型T1之物被隐式转换为类型T2之物，就必须在class T1内写一个类型装换函数或者在class T2内写一个non-expliccit-noe-argument(可被单一实参调用)的构造函数。如果你允许explicit构造函数存在，就得写出专门负责执行转换的函数，且不得为类型转换操作符或non-explicit-one-argument构造函数。
什么样的操作符合函数对此新type而言是合理的？这个取决于你将为你的class声明哪些函数。
什么样的标准函数应该驳回？那些正是你必须声明为private者。
谁该采用新type的成员？这个跟设计成员函数有关。你可以决定哪个成员为private，哪个为protected，哪个为private。
你的新type有多么一般化？或许你其实并非定义一个新type，而是定义一整个types家族。果真如此你就不应该定义一个新class，而是定义一个新的class template。
你真的需要一个新的type吗？如果只是定义新的派生类以便为既有的class添加机能，那么说不定单纯定义一或多个非成员函数或模板，更能够达到目标
宁以pass-by-reference-to-const替换pass-by-value传值调用会造成代码执行效率低
例如：
class Person
{
public:
Person();
virtual ~Person();
private:
std::string name;
std::string address;
};
class Student :public Person
{
public:
Student();
~Student();
private:
std::string schoolName;
std::string schoolAddress;
};
bool validateStudent(Student s);
int main()
{
Student plato; //定义Student对象
validateStudent(plato); //传值调用
return 0;
}可以看下传值过程中做了那些事情？
①执行6次构造函数：plato传入进函数的时候，需要调用1次Student的构造函数，Student构造函数执行前需要先构造Person ，因此还会调用1次Person类的构造函数。Person和Student两个类中共有4个string成员变量，因此还需要调用string的构造函数4次
②执行6次析构函数：当函数执行完成之后，传入validateStudent函数中的plato副本还需要执行析构函数，那么执行析构函数的时候分别要对应执行6次析构函数（Student+Person+4个string成员变量）
改进：
这种传递方式的效率高得多:没有任何构造函数或析构函数被调用，因为没有任何新对象被创建
以by reference方式传递参数也可以避免slicing(对象切割)问题
例如：
class Window
{
public:
std::string name()const;
virtual void display()const;
};
class WindowsWithScrollBars :public Window
{
public:
virtual void display()const;
};
void printNameAndDisplay(Window w)
{
std::cout<< w.name();
w.display();
}当执行下面代码时：
int main()
{
WindowsWithScrollBars wwsb;
printNameAndDisplay(wwsb); //WindowsWithScrollBars对象会被截断
return 0;
}因为printNameAndDisplay函数的参数为Window类型，所以即使我们传入的是WindowsWithScrollBars类型的对象，那么这个对象会被截断，只取WindowsWithScrollBars对象中属于基类（Window）的内容，然后传递给函数
因此被截断之后，不论如何调用，printNameAndDisplay函数中调用的display函数总是Window的display虚函数，不会是WindowsWithScrollBars中的display虚函数。因为多态只会发生在基类指针/引用指向于派生类的情况下，此处没有指针/引用
改进：
对于内置类型建议传值调用
C++编译器的底层，是把引用以指针的形式实现，因此引用传递就是指针的传递
如果你使用的对象属于内置类型（例如int），内置类型都相当小，传值调用往往比引用传递的效率高些
这条规则在STL的迭代器和函数对象中都被广泛引用
请记住：
1.尽量以pass-by-reference-to-const替换 pass-by-value。前者通常比较高效，并可避免切割问题(slicing problem)。必须返回对象时，别妄想返回其reference
2. 以上规则并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-value往往比较适当。
自己要记住，任何时候看到一个reference声明式，你都应该立刻问自己,它的另一个名称是什么？
看下面一段代码：我们有一个用来变现有理数的class，内含一个函数用来计算两个有理数的乘积
下面的那一段代码是合理的：
但如果返回值是引用，会存在什么问题呢？看下面的一些调用：
最后的那段代码存在问题，期望“原本就存在一个其值为3/10的Rational对象”并不合理。如果operator*要返回一个reference指向如此数值，它必须自己创建那个Rational对象。
方案1：
stack 空间或在 heap空间创建对象，例如：
friend const Rational&
operator*(const Rational& lhs, const Rational& rhs)
{
Rational result(lhs.n*rhs.n, lhs.d*rhs.d);
return result; //虽然编译器不报错，但是逻辑上是错误的
}原因：由于result是局部对象，函数结束之后局部对象（栈空间）就释放了，引起返回其引用是无效的，也就是说该函数返回了一个已经无效的对象的引用。
friend const Rational&
operator*(const Rational& lhs, const Rational& rhs)
{
Rational *result = new Rational(lhs.n*rhs.n, lhs.d*rhs.d);
return *result;//虽然编译器不报错，但是逻辑上是错误的
}
Rational w, x, y, z;
w = x*y*z; //相当于operator*(operator*(x,y),z);原因：在函数内，我们在堆上申请了一个对象，然后返回对象的引用，虽然函数结束之后对象仍存在，我们使用起来不会出错，但是这个函数内部建立的对象我们无法释放（因为我们无法获取其指针，不能进行delete操作）。因此会造成内存泄漏
方案2：返回一个静态局部变量
例如：
friend const Rational&
operator*(const Rational& lhs, const Rational& rhs)
{
static Rational result; //静态局部变量
//result=...; 将lhs乘以rhs，然后将结果保存在result中
return *result; //虽然编译器不报错，但是逻辑上是错误的
}再看下面的代码：先不管多线程安全的问题
bool operator==(const Rational& lhs,const Rational& rhs);
int main()
{
Rational a,b,c,d;
//...
if((a*b)==(c*d)){ //此if永远为真，因为operator*返回的都是同一个对象的引用
}
else{
}
}表达式((a*b) =- (c*d))总是被核算为true，不论a, b, c和d的值是什么!
原因：在operator== 被调用前，已有两个operator*调用式起作用，每一个都返回reference指向operator*内部定义的static Rational对象。因此operator==被要求将“operator*内的 static Rational对象值”拿来和“operator*内的 staticRational对象值”比较，那么当我们每回调用operator*函数的时候，每回返回的都是同一个静态局部变量的引用。
请记住：
绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。宁以non-member，non-friend替换member函数
象有个class用来表示网页浏览器。这样的 class可能提供的众多函数中，有一些用来清除下载元素高速缓存区(cache of downloaded elements)、清除访问过的URLs的历史记录等，例如：
许多用户会想一整个执行所有这些动作，因此webBrowser也提供这样-一个函数：
那么是成员函数好还是非成员函数呢？
解释：
1.提供non-member函数可允许对webBrowser 相关机能有较大的包裹弹性( packaging flexibility)，而那最终导致较低的编译相依度，增加 webBrowser的可延伸性。如果某些东西被封装，它就不再可见。愈多东西被封装，愈少人可以看到它。而愈少人看到它，我们就有愈大的弹性去变化它。
2.第二件值得注意的事情是,只因在意封装性而让函数“成为class 的 non-member”，并不意味它“不可以是另一个class 的member”
namespace和 classes不同，前者可跨越多个源码文件而后者不能。一个像webBrowser这样的class可能拥有大量便利函数，某些与书签(bookmarks>有关，某些与打印有关，分离它们的最直接做法就是将书签相关便利函数声明于一个头文件，将cookie相关便利函数声明于另一个头文件，以此类推。
这正是C++标准程序库的组织方式。
以此种方式切割机能并不适用于class成员函数，因为一个class必须整体定义，不能被分割为片片段段。一小部分。
将所有便利函数放在多个头文件内但隶属同一个命名空间，意味客户可以轻松扩展这一组便利函数。他们需要做的就是添加更多non-member non-friend函数到此命名空间内。
请记住：
宁可拿non-member non-friend 函数替换member函数。这样做可以增加封装性、包裹弹性（packaging flexibility）和机能扩充性若所有参数皆需类型转换，请为此采用non-member函数
先看一段关于类型转换的代码：
如果这样去使用代码：
int main()
{
Rational oneEighth(1, 8);
Rational oneHalf(1, 2);
Rational result = oneHalf*oneEighth;//正确
result = result*oneEighth; //正确
return 0;
}由于可以进行隐式的类型转换，因此我们还可以进行下面的有理数相乘
int main()
{
Rational oneHalf(1, 2);
//2隐式转换为Rational类型
//然后下面代码等价于result=oneHalf.operator*(2)
Rational result = oneHalf * 2;
return 0;
}在上面的代码中，编译器知道你正传递一个int对象，但是operator*()需要的是Rational，因此它调用Rational构造函数并赋予你所提供的int，就可以构造出一个临时的Rational对象,但是如果这样使用：下面是错误的代码
Rational oneHalf(1, 2);
//代码相当于2.operator*(oneHalf)
Rational result = 2 * oneHalf; //错误oneHalf是一个内含operator*函数的class的对象，所以编译器调用该函数。然而整数2 并没有相应的class，也就没有operator*成员函数。编译器也会尝试寻找可被以下这般调用的non-member operator*（也就是在命名空间内或在global作用域内）:
从上面的例子我们可以看到，如果operator*()为成员函数，在某些情况下即使存在隐式转换也不能成功执行。只有当参数被列于参数列(parameter list）内，这个参数才是隐式类型转换的合格参与者。地位相当于“被调用之成员函数所隶属的那个对象”—--即 this对象—一的那个隐喻参数，绝不是隐式转换的合格参与者。
例如：
class Rational
{
public:
Rational(int numerator = 0, int denominator = 1);
int numerator()const;
int denominator()const;
private:
//...
};
const Rational operator*(const Rational& lhs,const Rational& rhs)
{
return Rational(lhs.numerator()*rhs.numerator,
lhs.denominator()*lhs.denominator());
}那么下面的调用都是正确的：
int main()
{
Rational oneEighth(1, 8);
Rational oneHalf(1, 2);
Rational result;
result = oneHalf*oneEighth;
result = result*oneEighth;
result = oneHalf * 2;
result = 2 * oneHalf;
result = 2 * oneHalf*2;
result = oneHalf * 2 * oneHalf;
return 0;
}请记住：
1.如果你需要为某个函数的所有参数（包括被this这指针很所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member
2.如果一个函数不建议声明为member版本，那么就将该函数声明为non-member版本，而不是friend函数
你是否还在寻找稳定的海外服务器提供商？创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源，准确流量调度确保服务器高可用性，企业级服务器适合批量采购，新人活动首月15元起，快前往官网查看详情吧