C++博客-shangtang004

Handle assignment to self in operator=

魏尚堂 — Fri, 17 May 2013 07:00:00 GMT

Make sure operator= is well-behaved when an object is assigned to itself. Techniques include comparing addresses of source and target objects, careful statement ordering, and copy-and-swap.
Make sure that any function operating on more than one object behaves correctly if two or more of the objects are the same.

魏尚堂 2013-05-17 15:00 发表评论

Have assignment operators return a reference to *this

魏尚堂 — Fri, 17 May 2013 04:06:00 GMT

This is only a convention; code that doesn't follow it will compile. However, the convention is followed by all the built-in types as well as by all the types in the standard library (e.g., string, vector, complex, tr1::shared_ptr, etc.). Unless you have a good reason for doing things differently, don't.

魏尚堂 2013-05-17 12:06 发表评论

Never call virtual functions during construction or destruction

魏尚堂 — Fri, 17 May 2013 03:27:00 GMT

base class constructors execute before derived class constructors, derived class data members have not been initialized when base class constructors run. If virtual functions called during base class construction went down to derived classes, the derived class functions would almost certainly refer to local data members, but those data members would not yet have been initialized.Calling down to parts of an object that have not yet been initialized is inherently dangerous, so C++ gives you no way to do it.

#include

#include

void print(std::string str){std::cout << str<< std::endl;}

class Transaction {

public:

Transaction()

{

print("Transaction Constructor");

logTransaction();

}

virtual void logTransaction() const // =0;

{

print("Transaction Log");

}

};

class BuyTransaction: public Transaction

{

public:

BuyTransaction(){ print("BuyTransaction Constructor");}

virtual void logTransaction() const

{

print("BuyTransaction Log");

}

};

int main()

{

BuyTransaction dbc;

//dbc.logTransaction();

}

pure virtual functions cannot link.

[shangtang@BTSOM-1 study]$ g++ TestT.cpp

TestT.cpp: In constructor 'Transaction::Transaction()':

TestT.cpp:14: warning: abstract virtual 'virtual void Transaction::logTransaction() const' called from constructor

/tmp/ccXFzaHv.o: In function `Transaction::Transaction()':

TestT.cpp:(.text._ZN11TransactionC2Ev[Transaction::Transaction()]+0x7f): undefined reference to `Transaction::logTransaction() const'

collect2: ld returned 1 exit status

virtual function can compile, run, but with surprise result

[shangtang@BTSOM-1 study]$ ./a.out

Transaction Constructor

Transaction Log

BuyTransaction Constructor

The only way to avoid this problem is to make sure that none of your constructors or destructors call virtual functions on the object being created or destroyed and that all the functions they call obey the same constraint.

魏尚堂 2013-05-17 11:27 发表评论

Prevent exceptions from leaving destructors

魏尚堂 — Fri, 17 May 2013 02:56:00 GMT

Depending on the precise conditions under which such pairs of simultaneously active exceptions arise, program execution either terminates or yields undefined behavior. In this example, it yields undefined behavior.
C++ does not like destructors that emit exceptions!

#include

struct Exception

{

Exception(){std::cout << "Exception Constructor" << std::endl;}

~Exception(){std::cout << "Exception Destructor" << std::endl;}

};

class Widget {

public:

~Widget() {std::cout << "Widget Destructor" << std::endl; throw Exception();

} //this might emit an exception

void print(){std::cout << "print" << std::endl;}

};

void doSomething();

int main()

{

doSomething();

}

void doSomething()

{

std::vector v;

v.push_back(Widget());

std::vector::iterator it = v.begin();

while(it != v.end())

{

std::cout << "end" << std::endl;

(*it).print();

it++;

}

}
complie with g++

[shangtang@BTSOM-1 study]$ ./a.out

Widget Destructor

Exception Constructor

terminate called after throwing an instance of 'Exception'

Aborted (core dumped)

There are two primary ways to avoid the trouble.

1, Terminate the program if catch a exception, typically by calling std::abort (cstdlib) 2, Swallow the exception if catch a exception, print a log

魏尚堂 2013-05-17 10:56 发表评论

Virtual destructor from effective c++ edition 3

魏尚堂 — Mon, 13 May 2013 06:45:00 GMT

1, Declare destructors virtual in polymorphic base classes
why ? because C++ specifies that when a derived class object is deleted through a pointer to a base class with a non-virtual destructor, results are undefined.What typically happens at runtime is that the derived part of the object is never destroyed

2, if a class is not intended to be a base class, making the destructor virtual is usually a bad idea.
why? if a class have virtual functions, it has extra overhead(vptr).

3, In fact, many people summarize the situation this way: declare a virtual destructor in a class if and only if that class contains at least one virtual function

4,Sometimes, however, you have a class that you'd like to be abstract, but you don't have any pure virtual functions.
solution: declare pure virtual destructor.
There is one twist, however you must provide a definition for the pure virtual destructor, or linker will complain.

5, Not all base classes are designed to be used polymorphically. Neither the standard string type, for example, nor the STL container typesare designed to be base classes at all, much less polymorphic ones.

魏尚堂 2013-05-13 14:45 发表评论

sizeof 是在编译时执行还是运行时

魏尚堂 — Thu, 24 Jan 2013 02:26:00 GMT

thinking in c++ 有下面的例子，不太理解为什么这个宏中的条件表达式在编译时就执行了，在此作个记号

// A simple, compile-time assertion facility
#define STATIC_ASSERT(x) \
do { typedef int a[(x) ? 1 : -1]; } while(0)

int main()
{
STATIC_ASSERT(sizeof(int) <= sizeof(long)); // Passes
STATIC_ASSERT(sizeof(double) <= sizeof(int)); // Fails
return 0;
}

魏尚堂 2013-01-24 10:26 发表评论

类模板中的友元函数

魏尚堂 — Mon, 21 Jan 2013 02:48:00 GMT

template class dataList
{
public:

friend ostream& operator<<(ostream& outStream, const dataList &outList);

}

template ostream& operator<<(ostream& outStream, const dataList &outList)
{
//....
return outStream;
}
int main(int argc, char* argv[])
{
dataList testList;
cout << testList;
}

这个程序员是链接不过，
错误信息：

warning: friend declaration âstd::ostream& operator<<(std::ostream&, const dataList&)â declares a non-template function

note: (if this is not what you intended, make sure the function template has already been declared and add <> after the function name here)

/tmp/cc9DSuka.o: In function `main':

undefined reference to `operator<<(std::basic_ostream >&, dataList const&)'

collect2: ld returned 1 exit status

错误原因解释

The problem is that the compiler is not trying to use the templated operator<< you provided, but rather a non-templated version.

When you declare a friend inside a class you are injecting the declaration of that function in the enclosing scope. The following code has the effect of declaring (and not defining) a free function that takes a non_template_test argument by constant reference:

class non_template_test { friend void f( non_template_test const & ); }; // declares here: // void f( non_template_test const & );

The same happens with template classes, even if in this case it is a little less intuitive. When you declare (and not define) a friend function within the template class body, you are declaring a free function with that exact arguments. Note that you are declaring a function, not a template function:

template<typename T> class template_test { friend void f( template_test<T> const & t ); }; // for each instantiating type T (int, double...) declares: // void f( template_test const & ); // void f( template_test const & );  int main() {     template_test t1;     template_test t2; }

Those free functions are declared but not defined. The tricky part here is that those free functions are not a template, but regular free functions being declared. When you add the template function into the mix you get:

template<typename T> class template_test { friend void f( template_test<T> const & ); }; // when instantiated with int, implicitly declares: // void f( template_test const & );  template <typename T> void f( template_test<T> const & x ) {} // 1  int main() {    template_test t1;    f( t1 ); }

When the compiler hits the main function it instantiates the template template_test with type intand that declares the free function void f( template_test const & ) that is not templated. When it finds the call f( t1 ) there are two f symbols that match: the non-template f( template_test const & ) declared (and not defined) when template_test was instantiated and the templated version that is both declared and defined at 1. The non-templated version takes precedence and the compiler matches it.

When the linker tries to resolve the non-templated version of f it cannot find the symbol and it thus fails.

What can we do? There are two different solutions. In the first case we make the compiler provide non-templated functions for each instantiating type. In the second case we declare the templated version as a friend. They are subtly different, but in most cases equivalent.

Having the compiler generate the non-templated functions for us:

template <typename T> class test  { friend void f( test<T> const & ) {} }; // implicitly

This has the effect of creating as many non-templated free functions as needed. When the compiler finds the friend declaration within the template test it not only finds the declaration but also the implementation and adds both to the enclosing scope.

Making the templated version a friend

To make the template a friend we must have it already declared and tell the compiler that the friend we want is actually a template and not a non-templated free function:

template <typename T> class test; // forward declare the template class template <typename T> void f( test<T> const& ); // forward declare the template template <typename T> class test { friend void f<>( test<T> const& ); // declare f( test const &) a friend }; template <typename T> void f( test<T> const & ) {}

In this case, prior to declaring f as a template we must forward declare the template. To declare the ftemplate we must first forward declare the test template. The friend declaration is modified to include the angle brackets that identify that the element we are making a friend is actually a template and not a free function.
引用自 http://stackoverflow.com/questions/1810753/overloading-operator-for-a-templated-class
从上面我可以学到一点：
1，编译器匹配方法时非模板函数优先模板函数
2, 友元函数模板必须提前声明

魏尚堂 2013-01-21 10:48 发表评论

linux link

魏尚堂 — Thu, 17 Jan 2013 06:01:00 GMT

Linux Shell的通配符与正则表达式 http://blog.csdn.net/chen_dx/article/details/2463495

魏尚堂 2013-01-17 14:01 发表评论

c++ resource allocation new statement

魏尚堂 — Tue, 27 Nov 2012 02:03:00 GMT

Perform every resource allocation (e.g., new) in its own code statement which immediately gives the new resource to a manager object (e.g., auto_ptr).

This guideline is easy to understand and remember, it neatly avoids all of the exception safety problems in the original problem, and by mandating the use of manager objects it helps to avoid many other exception safety problems as well. This guideline is a good candidate for inclusion in your team's coding standards

link http://www.gotw.ca/gotw/056.htm

file I/O http://www.zwqxin.com/archives/cpp/use-sstream.html

魏尚堂 2012-11-27 10:03 发表评论