As we near the end of GSOC, I'm wrapping things up and getting the code ready for the final review. There's still a rare edge case that happens here and there but overall the new pixel-perfect feature works pretty well and will be usable for pixel art. Right now, the focus is to finish some UI changes and integrate this new option with a good user experience. Here's an example of the brush in action demonstrated by my mentor Emmett:

To conclude, I learned a lot from this experience and I feel more equipped in making more/better contributions now that I've worked on a bigger more complex task like making a pixel-perfect tool. Although the pace at which I wrote actual meaningful code was quite slow, I learned that most of the work was actually just researching and trying to understand how existing code worked.

I’ve realized that it’s been nearly a month since the last update about my GSoC project, so it’s time to publish a new one.

I’ve been upstreaming the Python bindings to their corresponding repositories and addressing the comments. Many thanks to Nico, Christophe, Volker, Ben and Carl (my mentor) for their comments! The CMake part has improved a lot and it’s almost ready to be merged. CI support should be ready for FreeBSD and Linux. We can add support for Windows if people are interested.

I’ll probably write a tutorial on how to add Python bindings to a library next week.

Most of the time programmers do not write new code. Instead, they read, try to understand,  extend, and fix bugs in existing code. While some parts of KDE are pretty new and follow modern standards, many parts are more then two decades old -- following obsolete coding principles, using outdated ways of solving problems, and having additions from several persons with different styles. Often when we read code, we immediately spot things we could improve.

Kent Beck's approach is applying a series of small tidyings that leads to structural change and an overall better software design. In his new book Tidy First? he describes his idea in three parts: Tidyings, how to manage tidyings, and software design theory.

In the first part the author introduces generic tidyings like dead code removal, moving declaration and initialization together, introducing new interfaces, or explicit parameters. Most proposals are not new, but it is a good reminder to follow them and fix these things wherever you come across them in code you are working with. After reading the first part, I felt motivated to create some tidying commits right away. For KDE more specific tidying could be added: Fix deprecation warnings from Qt and KF, replace C-style code by C++, use modern C++ (range-base for loop, initialization lists), fix compiler warnings.

The second part gives hints on how to organize and commit tidyings. Separate tidyings from new features or behavioral changes. Find a balance between asking for review of your tidyings too often or with too extensive reviews.

In the third part Kent Beck offers some basic ideas from software design, especially future options and code coupling.

The book is worth reading for both commercial and open-source developers. Both are facing similar issues. Open-source developers are not worrying about costs, but precious spare time dedicated to coding for their pet project. Every projects has bit rot and profits from regular tidyings by their developers.

People interested in software design will recognize the ideas from classic books like Structured Design or Refactoring: Improving the Design of Existing Code. Nevertheless, Tidy First? makes the knowledge easily accessible. Most chapters are only one to three pages long and the book stays below a hundred pages.

This is the first book of a planned series of small books. Kent Beck develops his ideas in his blog (partially pay-walled) and discusses his views with his readers. Some blog post make it into Kevin's weekly web reviews.

The KIO Framework has gained support for de-facto standard, cross-desktop thumbnail generators. This means that we have a support for thumbnails from 3rd party applications! On Linux systems, many applications that produce some kind of output, such as a 3D file or text document, ship a thumbnailer file that tells file managers how to create thumbnails of their files. One specific example I've used here in the images are STL files, for which we don't have our own KDE-specific thumbnailer plugin.

These thumbnailer files are currently used by Nautilus and Thunar, so we felt like we were missing out and wanted to join the party! :)

Thumbnailer files

Thumbnailer files are simple text files that tell the system what program we should run to generate a thumbnail. You can check what thumbnailers you have installed by running ls /usr/share/thumbnailers

For example, the STL thumbnailer file looks like this:

[Thumbnailer Entry]
TryExec=stl-thumb
Exec=xvfb-run --auto-servernum -w 0 stl-thumb -f png -s %s %i %o
MimeType=model/stl;model/x.stl-ascii;model/x.stl-binary;application/sla;

It tells the software running the thumbnailer what commands to use to generate the thumbnail, and what mimetypes it supports.

KDE Thumbnailer Plugins

On KDE side, we have used plugins for KIO, that reside in the kio-extras repository. They work just fine for our usecase in KDE apps, but nobody should need to write a KIO specific plugin for their application.

The changes to KIO

You can check the merge request for more in-depth details, but here's a summary of how I made it work side-by-side with our plugin system:

We utilize the KIO plugins always first if possible, since we know for sure they work. This is to avoid any possible regressions and oddities, and to keep the change as unintrusive as possible. When we encounter a mimetype that is not supported by our plugins, like STL files, we utilize a thumbnailer file instead.

This also means that it's transparent to users. Users do not have to worry which one they have installed.

Why make support for thumbnailer files then?

As mentioned earlier, no application should need to create a plugin for KIO just to make their thumbnails show up in our applications.

Thumbnailer files offer other benefits too, such as easing future transitions, (like from KF6 to KF7); working nicely with sandboxing, and being distributable in Flatpak bundles.

I am also working on moving our own plugins into thumbnailers, so we get the benefits from that too.

How can I test it out?

Currently it's only in the master branch of KIO, so if you really want to try it out, you will have to set up KDE Plasma development environment: https://develop.kde.org/docs/getting-started/building/kdesrc-build-setup/

When inside in the development environment, open Dolphin and enable the thumbnailers from preview settings.

Any help testing it would be very welcome! :) Let me know of any possible improvements and bugs!

Here's the relevant part of the new code that I have been working on in kis_tool_freehandhelper::paint :

if (m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::SIMPLE_SMOOTHING
            || m_d->smoothingOptions->smoothingType() == KisSmoothingOptions::WEIGHTED_SMOOTHING){
         // initial case where there isn't any lastDrawnPixel yet
         if(!m_d->hasLastDrawnPixel){
            currentPixel = info.pos();
            m_d->waitingPixel = currentPixel;
            paintLine(m_d->previousPaintInformation, KisPaintInformation(m_d->waitingPixel));
            m_d->lastDrawnPixel = m_d->waitingPixel;
            m_d->hasLastDrawnPixel = true;
            m_d->pixelInLineCount = 1;

        } else {
        // once there is a last drawn pixel 
            if (abs(currentPixel.x() - m_d->lastDrawnPixel.x()) > 1.5 || abs(currentPixel.y() - m_d->lastDrawnPixel.y()) > 1.5) {
            // current pixel is too far, draw the waiting pixel
                paintLine(m_d->lastDrawnPixel, KisPaintInformation(m_d->waitingPixel));
                m_d->pixelInLineCount += 1;
                m_d->lastDrawnPixel = m_d->waitingPixel;
                m_d->waitingPixel = currentPixel;
            }
            // check axis, if the currentpixel is in the same axis as the lastdrawnpixel, we can draw waiting pixel otherwise
            if (m_d->pixelInLineCount > 2 && (currentPixel.x() == m_d->lastDrawnPixel.x() || currentPixel.y() == m_d->lastDrawnPixel.y())) 
                    m_d->olderPaintInformation = m_d->previousPaintInformation;
                    //draw 
                    paintLine(m_d->KisPaintInformation(m_d->waitingPixel),KisPaintInformation(m_d->waitingPixel))
                    m_d->lastDrawnPixel = m_d->waitingPixel;
                }
                //otherwise just change update waiting pixel without drawing it
                m_d->waitingPixel = currentPixel;
                m_d->pixelInLineCount = 0;
            }
            // Enable stroke timeout only when not airbrushing.
            if (!m_d->airbrushingTimer.isActive()) {
                m_d->strokeTimeoutTimer.start(100);
            }
        }

Before a super glaring problem was that the algorithm made drawing very non-continuous, you barely get to see what gets drawn. When currentPixel gets too far from lastDrawnPixel, we have an infinite gap that doesn't get filled. In response, I took a page from Tom Cantwell's implementation, and if the currentPixel gets too far from the lastDrawnPixel, we draw the waitingPixel, except we draw the entire line from lastDrawnPixel to waitingpixel instead because only drawing the waitingpixel caused a lot of undrawn gaps likely due to mouse speed or the refresh rate of stuff getting read. Also if you notice, I made it so that the distance between currentPixel and lastDrawnPixel > 1.5 instead of > 1.0 because with just 1.0 we were not giving enough room to actually wait for the waitingPixel to be assessed and drawn if it's not a corner pixel.

In the context of waiting, I also added a pixelInLineCount so that we compound at least 2 pixels read before actually going through with the axis check because at less than two pixels read we either haven't drawn anything or we have only drawn one pixel and there can't be a complete check for a corner until we reach a scenario where there are three coordinates to check i.e. when we get to simulate the waiting pixel *lagging* behind currentPixel in an attempt to compare them and then see if it needs to be drawn.

There seems to only be one scenario left where the corner gets drawn, which also has to do with the fix we implemented. My running theory is that it has to do with how the line gets filled because sometimes although most lines will just be pixel-perfect with this line fill, we reach the middle of the Venn diagram where the mouse speed is just fast enough that we run into the > 1.5 distance check and so the line drawn isn't going through the axis check but then its also just slow enough where it draws exactly a horizontal into a vertical line between two close pixels.

The Freedesktop.org Specifications directory contains a list of common specifications that have accumulated over the decades and define how common desktop environment functionality works. The specifications are designed to increase interoperability between desktops. Common specifications make the life of both desktop-environment developers and especially application developers (who will almost always want to maximize the amount of Linux DEs their app can run on and behave as expected, to increase their apps target audience) a lot easier.

Unfortunately, building the HTML specifications and maintaining the directory of available specs has become a bit of a difficult chore, as the pipeline for building the site has become fairly old and unmaintained (parts of it still depended on Python 2). In order to make my life of maintaining this part of Freedesktop easier, I aimed to carefully modernize the website. I do have bigger plans to maybe eventually restructure the site to make it easier to navigate and not just a plain alphabetical list of specifications, and to integrate it with the Wiki, but in the interest of backwards compatibility and to get anything done in time (rather than taking on a mega-project that can’t be finished), I decided to just do the minimum modernization first to get a viable website, and do the rest later.

So, long story short: Most Freedesktop specs are written in DocBook XML. Some were plain HTML documents, some were DocBook SGML, a few were plaintext files. To make things easier to maintain, almost every specification is written in DocBook now. This also simplifies the review process and we may be able to switch to something else like AsciiDoc later if we want to. Of course, one could have switched to something else than DocBook, but that would have been a much bigger chore with a lot more broken links, and I did not want this to become an even bigger project than it already was and keep its scope somewhat narrow.

DocBook is a markup language for documentation which has been around for a very long time, and therefore has older tooling around it. But fortunately our friends at openSUSE created DAPS (DocBook Authoring and Publishing Suite) as a modern way to render DocBook documents to HTML and other file formats. DAPS is now used to generate all Freedesktop specifications on our website. The website index and the specification revisions are also now defined in structured TOML files, to make them easier to read and to extend. A bunch of specifications that had been missing from the original website are also added to the index and rendered on the website now.

Originally, I wanted to put the website live in a temporary location and solicit feedback, especially since some links have changed and not everything may have redirects. However, due to how GitLab Pages worked (and due to me not knowing GitLab CI well enough…) the changes went live before their MR was actually merged. Rather than reverting the change, I decided to keep it (as the old website did not build properly anymore) and to see if anything breaks. So far, no dead links or bad side effects have been observed, but:

If you notice any broken link to specifications.fd.o or anything else weird, please file a bug so that we can fix it!

Thank you, and I hope you enjoy reading the specifications in better rendering and more coherent look!

I like to call myself git “expert”, but I failed pretty badly few weeks ago I needed to bisect the kernel source code to figure out one bug.

General git bisect process is, You have two known commits, one is good and one is bad, and you keep searching for bad commit by splitting history in two. Lets say you have following changelog (not the actual changelog I was debugging, but example):

Future 聊天室

功能

账号管理

• 实现登录、注册、注销
• 实现找回密码（提高）

好友管理

• 实现好友的添加、删除、查询操作
• 实现显示好友在线状态
• 禁止不存在好友关系的用户间的私聊
• 实现屏蔽好友消息
• 实现好友间聊天

群管理

• 实现群组的创建、解散
• 实现用户申请加入群组
• 实现用户查看已加入的群组
• 实现群组成员退出已加入的群组
• 实现群组成员查看群组成员列表
• 实现群主对群组管理员的添加和删除
• 实现群组管理员批准用户加入群组
• 实现群组管理员/群主从群组中移除用户
• 实现群组内聊天功能

聊天功能

• 实现查看历史消息记录
• 实现用户间在线聊天
• 实现在线用户对离线用户发送消息，离线用户上线后获得通知
• 实现在线发送文件
• 实现在线用户对离线用户发送文件，离线用户上线后获得通知/接收
• 实现后台发送文件
• 实现用户在线时,消息的实时通知
  • 收到好友请求
  • 收到私聊
  • 收到加群申请

其他

• 使用 C++编程语言
• 使用 I/O 多路复用完成本项目
  • C++：Epoll ET 模式
• 使用数据库完成数据存储
  • Redis 和 mysql
  • 历史消息采用redis做告诉缓存，mysql来存储大量历史消息
• 数据库中数据的存储和取用使用序列化和反序列化完成(Json)
• 支持大量客户端同时访问
• 实现服务器日志，记录服务器的状态信息
• C/S 双端均支持在 CLI/Web 自行指定 IP:Port
• 实现具有高稳定性的客户端和服务器，防止在用户非法输入时崩溃或异常
  • 实现 TCP 心跳检测

遇到的问题

• 在客户端因某些原因异常退出时，服务端将无法正常处理其他请求.

  • 开始时服务端没有将新连接的描述符设置为非阻塞模式，导致客户端异常退出时服务端的接收recv一直在阻塞着读取，且无法处理其他请求

• 如何往线程池中传入类的成员函数.

  • auto task = [](){     类的成员函数 } m_pool.submit(task);
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    
    * `Tcp`传输为字节流传输，采用在每条消息前面加上`长度`来正确接收每条请求.
    * 在代码中往`redis`数据库中添加好友申请数据时，没有正确插入.
      * 由于好友申请当中包含时间，姓名等信息，中间含有**空格**，在redis的哈希表中无法插入.
      * 经过查阅在redis哈希表中，**空格**可以用`+`代替，在遇到`+`时会被转义为**空格**，或者存储为**十六进制**，但是这种方法在终端中的**空格**为灰色.
    
    * 在聊天界面如果输入带有`%`，服务器直接挂掉.
    
      * ```c++
        int redisAsyncContext::Lpush(const std::string &key, const std::string &value)
        {
            //std::string cmd = "lpush " + key + " " + value;
            this->m_reply = (redisReply *)redisCommand(this->m_connettion, "LPUSH %s %s", key.c_str(), value.c_str());
             // 检查 m_reply 是否为 NULL
            if (this->m_reply == NULL) {
                std::cerr << "Error: redisCommand returned NULL" << std::endl;
                return -1; // 或其他合适的错误值
            }
        
            // 检查 m_reply 类型
            if (this->m_reply->type != REDIS_REPLY_INTEGER) {
                std::cerr << "Error: Expected integer reply" << std::endl;
                freeReplyObject(this->m_reply);
                return -1; // 或其他合适的错误值
            }
            int num  = this->m_reply->integer;
            freeReplyObject(this->m_reply);
            std::cout << "G" << std::endl;
            return num;
        }
    

  • 在执行下面两句是，%会被替换为cmd.c_str(),导致无法将消息插入历史记录表，导致出现错误.

    1 2	std::string cmd = "lpush " + key + " " + value; this->m_reply = (redisReply *)redisCommand(this->m_connettion, cmd.c_str());

  • 只要更改为下面即没有问题

    1	this->m_reply = (redisReply *)redisCommand(this->m_connettion, "LPUSH %s %s", key.c_str(), value.c_str());

• 在某次测试时，新注册账号id为0614897828,导致与该账号聊天的账号进入聊天界面时，0614897828发送的消息会在他人界面显示为通知消息.

  • 由于与人聊天时会在数据库中创建有排序集合来记录某人正在聊天的人的id.运行时通过查看发现，其余账号与0614897828聊天时，数据库中记录账号为614897828.
  • 更换为首位非0的id就不会出现该问题.
  • redis会将有序集合中的score字段字符串中的0去除.将从字符串的首位非0开始存储.

• 在进入好友私聊界面时，客户端新建了来接收消息，同时主线程发消息，主线程通过判断用户是否键入Esc来退出聊天界面，在输入Esc时，接收消息线程无法正确回收，无法退出聊天界面.

  • 在接收消息线程中来判断标志位来结束该线程，主线程在键入Esc时，将标志位设置为false,但由于客户端的recv为阻塞，导致无法及时获取到标志位的更改.
  • 在键入Esc时，服务器向客户端发送退出信号，这样就可以正确及时的获取到标志位的更改，从而正确退出.

• 在进行发送文件时，服务器会先将文件存储在本地，但是服务器存储的文件会多写入一些信息，导致接收文件大小偏大.

  • 由于在用户登陆进入之后，会有一个线程每5秒向服务器送送刷新请求，导致服务器会将刷新请求当作文件内容写入文件，导致接收文件不一致
  • 在进入文件收发菜单后，关闭实时刷新，在文件结束后，再将实时刷新打开.

• 实现后台发送文件，由于会有实时刷新的存在，会导致文件发送不准确.

  • 在发送文件时，重新创建一个socket连接到服务器，在将发送这个文件交给另外一个线程
  • 初始时在用户选择发送文件时开始线程，但会导致主线程与发送线程会同时运行菜单.主线程继续循环菜单，而发送线程运行获取发送文件的信息。
    • 更改线程开始时间，在用户选择发送文件时，获取到发送文件信息后，在启动线程.
    • 新连接的socket发送文件后，服务器不用手动断开连接，服务器有心跳检测，会在一段时间后断开.

eventfd

详解

是一个Linux系统调用，也是一种进程间通信(IPC)机制，主要通过使用文件描述符生成和使用事件通知.

提供了一种在不同进程之间或同一进程内的线程之间的同步事件的方法.

异常处理

异常是程序在执行期间产生的问题。c++异常是指在程序运行时发生的特殊情况.

异常提供了一种转移程序控制权的方式。C++ 异常处理涉及到三个关键字：try、catch、throw

关键字：try、catch、throw。

• throw: 当问题出现时，程序会抛出一个异常。这是通过使用 throw 关键字来完成的。

• catch: 在您想要处理问题的地方，通过异常处理程序捕获异常。catch 关键字用于捕获异常

• try: try 块中的代码标识将被激活的特定异常。它后面通常跟着一个或多个 catch 块

1
2
3
4
5
6
7
8
9
10
11
12
13

try
{
   // 保护代码
}catch( ExceptionName e1 )
{
   // catch 块
}catch( ExceptionName e2 )
{
   // catch 块
}catch( ExceptionName eN )
{
   // catch 块
}

nlohmann::json

链接

SIGPIPE

SIGPIPE 是一种信号，当一个进程尝试向一个已经关闭的或不可写的管道或套接字写数据时，会触发这个信号。默认情况下，接收到 SIGPIPE 信号的进程会终止。这在网络编程中会导致一些问题，因为如果客户端断开连接，服务器进程在写入数据时会因为这个信号而意外退出。

在网络编程中，特别是使用套接字进行通信时，忽略 SIGPIPE 信号是一个常见的做法。这样可以防止进程因为 SIGPIPE 信号而意外终止。相反，程序可以通过检测 send 或 write 操作的返回值来处理错误，从而使程序更加健壮。

后续问题

1. 初始客户端构思方面的缺陷，导致实时消息没有线程及时接收。

   当前处理方式为服务端将通知消息放入数据库当中，客户端在登陆之后，增加一个线程来定时执行刷新函数，刷新数据库中的通知消息

   可以优化为在客户端登陆之后，采用多线程的方式来处理相关操作.

2. 目前只有在历史消息这一操作涉及到redis+mysql的处理方式.

   可以将一些重要信息也采用redis+mysql的处理方式(涉及到redis的存储方式，redis存储于内存当中，会造成数据丢失的情况)

   可以考虑将redis全部做为缓存的形式，将重要信息与历史消息类似，达到一定情况下放入mysql,使数据更加的持久化.

后续学习

1. 继续学习epoll的相关内容.

2. 了解其余网络框架，使得该项目的服务端更加的健壮.

3. 了解消息队列的信息同步的问题.

4. 熟悉零拷贝的过程，以及零拷贝的具体实现.

5. 序列化的相关协议，json与其他序列化的区别、json的优点，以及为什么不用其他的序列化

6. 数据库的深入学习，了解redis的缓存穿透、缓存雪崩、缓存击穿。加强对mysql数据库的学习.

7. 加强对网络协议相关知识的学习.

强制类型转换

C++提供了四个强制类型转换的关键字：

• static_cast
• const_cast
• reinterpret_cast
• ``dynamic_cast`

static_cast

1

static_cast<目标类型>(表达式)

1
2

int num = 2;
double result =static_cast<double>(num);

该运算符将表达式转换为目标类型。但没有进行运行时类型检查来保证转换的安全性。

主要用法

1. 用于类层次结构中父类和子类之间指针或引用的转换.进行上行转换是安全的（即将子类的指针或引用转换成父类是正确的）；进行下行转换的时候，由于没有动态类型检查，所以是不安全的。继承必须为public
2. 用于基本类型之间的转换，如int与char，安全性也需要程序员来保证
3. 把空指针转换为目标类型的空指针

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

class Person
{
public:
    void  print()
    {
        cout << "Person " << endl;
    }
};

class Son : public Person
{
public:
    void print()
    {
        cout << "Son " << endl;
    }
};

void print1(Person *p)
{
    p->print();
}

int main()
{
    Son s;
    print1(static_cast<Person *>(&s));
    return 0;
}

const_cast

const_cast是c++中专用于处理与const相关的强制类型转换的关键字

其功能为：为一个变量重新设定其const描述.

即：const_cast可以为一个变量强行增加或删除其const限定.

需要明确的是，即使用户通过const_cast强行去除了const属性，也不代表当前变量从不可变变为了可变。const_cast只是使得用户接管了编译器对于const限定的管理权，故用户必须遵守“不修改变量”的承诺。如果违反此承诺，编译器也不会因此而引发编译时错误，但可能引发运行时错误。

1. const_cast可用于更改const成员函数内的非const类成员。
2. const_cast可用于将const数据传递给不接收const的函数。
3. const_cast<>里边的内容必须是引用或者指针。
4. const_cast也可以用来抛弃volatile和__unaligned属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

class Student
{
private:
int roll;
public:
Student(int r) :roll(r) {}
void fun() const
{
(const_cast<Student*> (this))->roll = 5;
}
int getRoll() { return roll; }
};

int main() {
    Student student(3);
    std::cout << "Old roll number: " << student.getRoll() << std::endl;
    student.fun();
    std::cout << "New roll number: " << student.getRoll() << std::endl;

    // const_cast只能调节类型限定符，不能更改基础类型
    int a1 = 40;
    //const int* b1 = &a1;
    //char* c1 = const_cast <char*> (b1); // 编译程序时出错

    const volatile int* d1 = &a1;
    std::cout << "typeid of d1 " << typeid(d1).name() << '\n'; // int const volatile *
    int* e1 = const_cast <int*> (d1);
    std::cout << "typeid of e1 " << typeid(e1).name() << '\n'; // int *
    
    return 0;
}

在const成员函数fun()中，编译器将“this”视为“ const student const this”，即“this”是指向常量对象的常量指针，因此编译器不允许通过以下方式更改数据成员“这个”指针。const_cast将“this”指针的类型更改为“student const this”。

const_cast比简单类型转换更安全。从某种意义上讲，如果强制类型与原始对象不相同，则强制转换不会发生，这是比较安全的。

1
2
3

int a=20;
const int *p=&a;
char *c1=const_cast<char*> (p);//编译时程序出错

reinterpret_cast

reinterpret,即重新解释.

该强制类型转换的作用是提供某个变量在底层数据上的重新解释.

当我们对一个变量使用reinterpret_cast后，编译器将无视任何不合理行为，强行将被转换变量的内存数据重解释为某个新的类型。用于进行各种不同类型的指针之间、不同类型的引用之间以及指针和能容纳指针的整数类型之间的转换。转换时，执行的是逐个比特复制的操作。 它不检查指针类型和指针所指向的数据是否相同。

需要注意的是，reinterpret_cast要求转换的两个数据所占用的内存大小一致，否则会引发编译时错误.

1

data_type *var_name = reinterpret_cast <data_type *>(pointer_variable);

使用 reinterpret_cast 的目的：

1. reinterpret_cast是一种非常特殊且危险的类型转换操作符。并且建议使用适当的数据类型使用它，即（指针数据类型应与原始数据类型相同）。
2. 它可以将任何指针类型转换为任何其他数据类型。
3. 当我们要使用位时使用它。
4. 它仅用于将任何指针转换为原始类型。
5. 布尔值将转换为整数值，即0表示false，1表示true。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

class A {
public:
    int a;
    A(int i) :a(i) {}
    void fun_a()
    {
        std::cout << "In class A\n";
    }
};

class B {
public:
    int b;
    B(int i) :b(i) {}
    void fun_b()
    {
        std::cout << "In class B\n";
    }
};

void testReinterpretCast() {
    B *x = new B(5);
    A* y = reinterpret_cast<A*>(x);
    y->fun_a();                      // In class A
    std::cout << y->a << std::endl;  // 5
}

dynamic_cast

dynamic用于在运行时实现向下类型转换。

1

dynamic_cast <type-id> (expression)

将expression转换为type-id类型,type-id必须是类的指针，类的引用或者是void,

如果type-id是一个指针，那么expression也是一个指针，是引用的话同为引用

特点如下：

1. 它是在运行是进行处理的，其余三个都是在编译时完成. 运行时进行类型检查
2. 不能用于内置的基本数据类型之间的强制转换
3. dynamic_cast 要求 <> 内所描述的目标类型必须为指针或引用。dynamic_cast 转换如果成功的话返回的是指向类的指针或引用，转换失败的话则会返回 nullptr。
4. 在类的转换时，在类层次上进行向上转换（子类指针指向父类指针），与static_cast的效果是一样的。在进行父类指针向子类指针的转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。
5. 向下转换的成功与否还与将要转换的类型有关，即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。在C++中，编译期的类型转换有可能会在运行时出现错误，特别是涉及到类对象的指针或引用操作时，更容易产生错误。dynamic_cast操作符则可以在运行期对可能产生问题的类型转换进行测试。
6. 使用 dynamic_cast 进行转换的，基类中一定要有虚函数，否则编译不通过（类中存在虚函数，就说明它有想要让基类指针或引用指向派生类对象的情况，此时转换才有意义）。这是由于运行时类型检查需要运行时类型信息，而这个信息存储在类的虚函数表中，只有定义了虚函数的类才有虚函数表。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

class AA {
public:
    virtual void print() {
        cout << "in class AA" << endl;
    };
};

class BB :public AA {
public:
    void print() {
        cout << "in class BB" << endl;
    };
};

void testDynamicCast() {
    AA* a1 = new BB; // a1是A类型的指针指向一个B类型的对象
    AA* a2 = new AA; // a2是A类型的指针指向一个A类型的对象

    BB* b1, * b2, * b3, * b4;

    b1 = dynamic_cast<BB*>(a1);// not null，向下转换成功，a1 之前指向的就是 B 类型的对象，所以可以转换成 B 类型的指针。
    if (b1 == nullptr) 
        cout << "b1 is null" << endl;
    else               
        cout << "b1 is not null" << endl;

    b2 = dynamic_cast<BB*>(a2);// null，向下转换失败
    if (b2 == nullptr) 
        cout << "b2 is null" << endl;
    else               
        cout << "b2 is not null" << endl;

    // 用 static_cast，Resharper C++ 会提示修改为 dynamic_cast
    b3 = static_cast<BB*>(a1);// not null
    if (b3 == nullptr) 
        cout << "b3 is null" << endl;
    else               
        cout << "b3 is not null" << endl;

    b4 = static_cast<BB*>(a2);// not null
    if (b4 == nullptr) 
        cout << "b4 is null" << endl;
    else               
        cout << "b4 is not null" << endl;

    a1->print();// in class BB
    a2->print();// in class AA

    b1->print();// in class BB
    //b2->print();    // null 引发异常
    b3->print();// in class BB
    b4->print();// in class AA
}

详细