C++博客-tommy-随笔分类-C++语言与规范

vs2012 编译 Qt5.0

Tommy Liang — Sat, 19 Jan 2013 05:23:00 GMT

资料转自网络:

原文在此： http://www.qtcn.org/bbs/simple/?t52158.html

1 安装vs2012 update1

2 下载qt5源码包，记住，windows下要下载zip结尾的，不要看到tar.gz的小就下它，tar.gz的源码包不能直接在windows下编译

编译

1) 我要编译x86，所以打开vc x86命令提示符，其他版尚未成功

2) cd \qt-everywhere-opensource-src-
configure -prefix %CD%\qtbase -opensource -nomake tests -nomake examples -mp
如果想编译例子，可以去掉-nomake examples

3) 执行nmake 开始编译。

Tommy Liang 2013-01-19 13:23 发表评论

Qt moc 的一个诡异提示

Tommy Liang — Tue, 21 Jun 2011 16:06:00 GMT

Warning: No relevant classes found. No output generated

百思不得其解之下，想起来有个注释是从word拷过来的，当时提示了一下需要unicode保存，没留意。。。

检查头文件，果然是unicode编码，改为gb2312，编译通过。

Tommy Liang 2011-06-22 00:06 发表评论

关于 shared_from_this 的一个要点

Tommy Liang — Thu, 24 Mar 2011 15:29:00 GMT

不能在构造函数中使用 shared_from_this，正确的做法如下：google自: http://boost.2283326.n4.nabble.com/enabled-shared-from-this-bad-weak-ptr-exception-online-doc-explanation-td2583370.html

Since in the current version you cannot call shared_from_this() in a
constructor, you can't initialize your members with an expression that
invloves shared_from_this(). Instead, you can set your shared_ptr's in
some initializing member function that would be called after the
object is constructed:

struct B;
struct A
{
A(shared_ptr b)
{
//...
}
};

class B : public enable_shared_from_this
{
shared_ptr a_;
public:
void init()
{
a_.reset(new A(shared_from_this()));
}
};

main()
{
shared_ptr b(new B);
b->init();
}

...also you can wrap initialization in a static constructing function:

class B....
{
// like in the previous example
B()
{}
public:
static shared_ptr create()
{
shared_ptr result(new B());
result->init();
return result;
}
};

main()
{
shared_ptr b(B::create());
}

Tommy Liang 2011-03-24 23:29 发表评论

Boost.SmartPtr

Tommy Liang — Wed, 23 Mar 2011 02:01:00 GMT

Use scoped_ptr when

A pointer is used in a scope where an exception may be thrown

There are several control paths in a function

The lifetime of a dynamically allocated object can be limited to a specific scope

Exception safety is important (always!)

Use shared_ptr in the following scenarios:

When there are multiple clients of an object, but no explicit owner

When storing pointers in Standard Library containers

When passing objects to and from libraries without (other) expressed ownership

When managing resources that need special cleanup^[9]

Use weak_ptr to

Break cyclic dependencies

Use a shared resource without sharing ownership

Avoid dangling pointers

check:http://my.oschina.net/jackwgm/blog/6695?catalog=23886

Tommy Liang 2011-03-23 10:01 发表评论

关于C++的 explicit关键字

Tommy Liang — Sat, 04 Feb 2006 21:16:00 GMT

简而言之：explicit修饰的构造函数不能担任转换函数

这个《ANSI/ISO C++ Professional Programmer's Handbook 》是这样说的

explicit Constructors
A constructor that takes a single argument is, by default, an implicit conversion operator, which converts its argument to
an object of its class (see also Chapter 3, "Operator Overloading"). Examine the following concrete example:
class string
{
private:
int size;
int capacity;
char *buff;
public:
string();
string(int size); // constructor and implicit conversion operator
string(const char *); // constructor and implicit conversion operator
~string();
};
Class string has three constructors: a default constructor, a constructor that takes int, and a constructor that
constructs a string from const char *. The second constructor is used to create an empty string object with an
initial preallocated buffer at the specified size. However, in the case of class string, the automatic conversion is
dubious. Converting an int into a string object doesn't make sense, although this is exactly what this constructor does.

Consider the following:
int main()
{
string s = "hello"; //OK, convert a C-string into a string object
int ns = 0;
s = 1; // 1 oops, programmer intended to write ns = 1,
}
In the expression s= 1;, the programmer simply mistyped the name of the variable ns, typing s instead. Normally,
the compiler detects the incompatible types and issues an error message. However, before ruling it out, the compiler first
searches for a user-defined conversion that allows this expression; indeed, it finds the constructor that takes int.
Consequently, the compiler interprets the expression s= 1; as if the programmer had written
s = string(1);
You might encounter a similar problem when calling a function that takes a string argument. The following example
can either be a cryptic coding style or simply a programmer's typographical error. However, due to the implicit
conversion constructor of class string, it will pass unnoticed:
int f(string s);
int main()
{
f(1); // without a an explicit constructor,
//this call is expanded into: f ( string(1) );
//was that intentional or merely a programmer's typo?
}
'In order to avoid such implicit conversions, a constructor that takes one argument needs to be declared explicit:
class string
{
//...
public:
explicit string(int size); // block implicit conversion
string(const char *); //implicit conversion
~string();
};
An explicit constructor does not behave as an implicit conversion operator, which enables the compiler to catch the
typographical error this time:
int main()
{
string s = "hello"; //OK, convert a C-string into a string object
int ns = 0;
s = 1; // compile time error ; this time the compiler catches the typo
}
Why aren't all constructors automatically declared explicit? Under some conditions, the automatic type conversion is
useful and well behaved. A good example of this is the third constructor of string:
string(const char *);

The implicit type conversion of const char * to a string object enables its users to write the following:
string s;
s = "Hello";
The compiler implicitly transforms this into
string s;
//pseudo C++ code:
s = string ("Hello"); //create a temporary and assign it to s
On the other hand, if you declare this constructor explicit, you have to use explicit type conversion:
class string
{
//...
public:
explicit string(const char *);
};
int main()
{
string s;
s = string("Hello"); //explicit conversion now required
return 0;
}
Extensive amounts of legacy C++ code rely on the implicit conversion of constructors. The C++ Standardization
committee was aware of that. In order to not make existing code break, the implicit conversion was retained. However, a
new keyword, explicit, was introduced to the languageto enable the programmer to block the implicit conversion
when it is undesirable. As a rule, a constructor that can be invoked with a single argument needs to be declared
explicit. When the implicit type conversion is intentional and well behaved, the constructor can be used as an
implicit conversion operator.

Tommy Liang 2006-02-05 05:16 发表评论