C++博客-一步一个脚印，走在自己前面！

Qt GUI Programming Basic

仄洛 — Mon, 21 May 2007 08:14:00 GMT

摘要: Qt GUI programming basic 阅读全文

仄洛 2007-05-21 16:14 发表评论

快捷菜单编程

仄洛 — Sun, 20 May 2007 07:47:00 GMT

摘要: 快捷菜单编程阅读全文

仄洛 2007-05-20 15:47 发表评论

DLL编程专题

仄洛 — Sun, 20 May 2007 03:32:00 GMT

摘要: DLL编程专题。阅读全文

仄洛 2007-05-20 11:32 发表评论

sizeof操作符使用注意

仄洛 — Sat, 19 May 2007 08:14:00 GMT

sizeof操作符使用注意：

先看下面的测试代码(1)和(2)：
=====================================================================

测试代码(1) :
const char* a[] = { "a", "bcedf" };

// 测试下面的sizeof(a)，它的结果是’8’, 原因在于a是指针数组，里面存储的是指针元素。

// 在这里是两个指针元素的数组。故为4*2=8.

cout << sizeof(a) << endl; // print '8'

// test sizeof(*a), sizeof(a[0]), sizeof(a[0][0])

cout << sizeof(*a) << endl; // print '4' 这里*a是求出第一个字符串的地址,注意a是指针的指针。

cout << sizeof(a[0]) << endl;// print '4' 这里是a[0] = *a,跟上面的一样。

cout << sizeof(a[0][0]) << endl; // print '1' 这里是第一个字符串的第一个字符a，一个字节。

测试代码(2) :
struct TestStruct {
char c_elem; // 1 bytes
int int_elem; // 4 bytes
};

cout << sizeof(TestStruct) << endl;     // it prints '8' .

struct TestStruct1 {
    char c_elem1;
    char c_elem2:
    char c_elem3;
    ...                     // num 个char类型数据成员
};
   cout << sizeof(TestStruct1) <
// 输出的结果与具体的系统结构有关，此处是32位机，故为了寻址的快捷和方便，系统会自动的填补(padding).
// int类型是4个字节，char类型为1个字节，但是此处会自动填补3个字节到struct结构中使其成为4个字节。
// 但是如果struct中只有一种类型，譬如char或int类型时，不会产生此种填补的情况。但是如果不是，它会输出
// 4的倍数个字节。
======================================================================

仄洛 2007-05-19 16:14 发表评论

读写磁盘文件专题--采用C/C++/MFC/WIN32(API)方式

仄洛 — Sat, 19 May 2007 07:54:00 GMT

摘要: 采用C/C++/MFC/WIN32(API)方式读写磁盘文件的方法。阅读全文

仄洛 2007-05-19 15:54 发表评论

求N个三角形的最大最小内切圆的方法

仄洛 — Wed, 09 May 2007 02:25:00 GMT

摘要: 阅读全文

仄洛 2007-05-09 10:25 发表评论

编译期的依赖性系列

仄洛 — Thu, 29 Mar 2007 07:02:00 GMT

该文章包括3个部分。

仄洛 2007-03-29 15:02 发表评论

编译器何时为你产生默认构造函数

仄洛 — Tue, 27 Mar 2007 02:21:00 GMT

总结：
    有四种情况，会导致“编译器必须为未声明构造函数的classes合成一个默认构造函数”。C++ 标准把那些合成物称为隐含的有用默认构造函数。被合成出来的构造函数只能满足编译器(非程序)的需要。它之所以能够完成任务，是借着“调用成员对象或基类的默认构造函数”或是“为每一个对象初始化其虚函数机制或虚基类机制”而完成的。至于没有存在那四种情况而又没有声明构造函数的类，我们说它们拥有的是隐含的无用默认构造函数，实际上它们并不被合成出来。
    在合成的默认构造函数中，只有基类子对象和成员对象会被初始化。所有其它的非静态数据成员，如整数、整数指针、整数数组等等都不会被初始化。这些初始化操作对程序而言有需要，但对编译器而言则没必要。如果程序需要一个“把某指针设为0”的默认构造函数，那么提供它的人应该是程序员。

    C++新手一般有两个常见的误解：
1）任何类如果没有定义默认构造函数，编译器就会合成出它来。
2）编译器合成出来的默认构造函数会明确设定“类中每一个数据成员的默认值”。

正如你所见，上述两个没有一个是真的！
-------------------------------------------------------------------------------------------
Summary:
   There are four characteristics of a class under which the compiler needs to synthesize a default constructor for classes that declare no constructor at all. The Standard refers to these as implicit, nontrivial default constructors. The synthesized constructor fulfills only an implementation need. It does this by invoking member object or base class default constructors or initializing the virtual function or virtual base class mechanism for each object. Classes that do not exhibit these characteristics and that declare no constructor at all are said to have implicit, trivial default constructors. In practice, these trivial default constructors are not synthesized.

Within the synthesized default constructor, only the base class subobjects and member class objects are initialized. All other nonstatic data members, such as integers, pointers to integers, arrays of integers, and so on, are not initialized. These initializations are needs of the program, not of the implementation. If there is a program need for a default constructor, such as initializing a pointer to 0, it is the programmer's responsibility to provide it in the course of the class implementation.

Programmers new to C++ often have two common misunderstandings:

1) That a default constructor is synthesized for every class that does not define one
2) That the compiler-synthesized default constructor provides explicit default initializers
for each data member declared within the class

As you have seen, neither of these is true.

--------------------------------------------------------------------------------------------

仄洛 2007-03-27 10:21 发表评论

组件间的物理关系

仄洛 — Tue, 20 Mar 2007 12:56:00 GMT

   开发可维护、易测试和可重用的软件需要全面的物理设计和逻辑设计的知识。物理设计研究组织的问题，超出了逻辑领域的范畴，物理设计很容易影响可测量的特性，例如运行时间、编译时间、连接时间以及可执行文件大小。

   一个组件是由一个.c文件和.h文件组成的物理实体，它具体表达了一个逻辑抽象的具体实现。一个组件一般包含一个、两个甚至多个类，已经需要用来支持全部抽象的适当的自由运算符。一个组件（而不是一个类）是逻辑设计和物理设计的适当单位，因为它能够：
   1)让若干逻辑实体把一个单一的抽象表现为一个内聚单位；
   2)考虑到物理问题和组织问题；
   3)在其他程序中选择性地重用编译单元。

   一个组件的逻辑接口仅限于指能够被客户程序通过编译访问的部分，而物理接口则包括它的整个头文件。如果在一个组件的物理接口中使用了一个用户自定义类型T，即使T是一个封装的逻辑细节，也可能迫使那个组件的客户程序在编译时依赖T的定义。
   组件是自我包含的、内聚的和潜在的可重用的设计单位。在一个组件内部声明的逻辑结构不应该定义在那个组件之外。一个组件的.c文件应该直接包含它的.h文件，以确保.h文件可基于它自己进行语法分析。对于每一个需要的类型定义，都始终包含其头文件，而不是依赖一个头文件去包含另一个，这样，当一个组件允许一个#include 指令从其头文件中被删除时不会出现问题。想要改进可用性、可重用性和可维护性，如果某个带有外部连接的结构没有在一个组件的.h文件声明，那么我们应该避免把该结构放在这个组件的.c文件中。同样的原因，我们应该避免使用局部声明去访问有外部连接的定义。

   最后友元关系虽然表面上是一个逻辑关系，但会影响到物理设计。在一个组件内部，（局部的）友元关系是那个组件的一个封装的实现细节。为了改进可用性和用户可扩展性，一个容器类常常会把同一个组件内的迭代器视作友元，不会破坏封装。友元关系只会直接影响访问权限但不会隐含依赖。

仄洛 2007-03-20 20:56 发表评论

输出字符'A'/'a'的解析

仄洛 — Mon, 15 Jan 2007 02:59:00 GMT

输出字符'A'/'a'的代码段：

1     // Test1: Directly insert 0x0A and 0x41 to ostream
2    cout << 0x0A;    // print type int 10
3
4    cout << ' ';
5
6    cout << 0x41;    // print type int 65, which is decimal number of 'A'.
7    cout << ' ';
8
9    // Test2: Directly insert '\x41' to ostream
10    cout << '\x41';    // '\x41' is transformed char, which means type char 'A'.
11                       // So, it prints type char 'A' on screen.
12    cout << ' ';
13
14    // Test3: First assign 0x41 to char variable, then output it.
15    char char_out = 0x41;    // char_out is equal 'A' which is type int 65.
16    cout << char_out;        // it prints type char 'A' on screen.
17
18    cout << ' ';
19    // Test4: First cast 0x0A to char, then output it.
20    cout << static_cast<char>(0x41); // it prints type char 'A' on screen.
21
22    cout << ' ';

23    // Test5: Directly insert hexdecimal type number of 'A'
24     cout << std::hex /*<< std::showbase*/ << 0x41; // it prints string literal "41"
25    cout << ' ' << std::hex << 0x0A; // it prints type char 'a' on screen.
26    int int_out = '0x41';
27    cout << int_out; // it prints type int 8342**
28
29    cout << endl;

0x41是字符'A'的16进制表示方式，它的10进制数是65，\x41是字符'A'的转义字符。而0x0A跟字符'A'没有丝毫关系，顶多就是0x0A借用了字符'A'而已。故如果想在屏幕上输出字符'A'可将其转义字符直接插入输出流中，或者将0x41转化为字符类型，然后插入，不得使用0x41直接插入，因为0x41本身是int类型的10进制数65。同时也不可以将'0x41'直接插入输出流，因为'0x41'是int类型的数。
可以尝试使用控制符std::hex来插入字符'a'到输出流。

仄洛 2007-01-15 10:59 发表评论