Week 7 of my 14-week GSoC project has finished, which means that it’s time for a midterm update! Many things have happened since the last update.

I added support for KI18n, KGuiAddons, KNotifications, KUnitConversion and KXMLGui. That was faster than expected. I also created a small unit conversion demo using KUnitConversion (it’s written in Python):

We have decided to move on to upstream the bindings to their corresponding repositories. For that, I set up a development environment and I’m now adding the code to each library.

Currently, I have three separate ideas. First idea is that in kis_tool_freehand where stroke initialization and end stroke exists, we populate a vector, filter out extra points and then take out corner pixels before passing it down. The problem I am running into with this method is that I can't exactly figure out whats the best way to access this vector because trying to access it as a global vector seems risky and also doesn't work because putting #include "plugins/paintops/defaultpaintops/brush/kis_brushop.h" in kis_tool_freehand seems to have directory issues. Maybe I should try storing the vector another way? This time I will try passing it down, but I am a little worried if this will work because, in kis_tool_freehand, I have smoothedPoints ( the filtered points vector) declared in endStroke() which isn't part of the function hierarchy. I will still try to pass a duplicate vector through the paintEvent in doStroke all the way to paintLine in brushop to see if it works.

For reference this is the function hierarchy:
Beginning ->void KisToolProxy::forwardToTool(ActionState state, KisTool::ToolAction action, QEvent *event, const QPointF &docPoint)

->void KisToolFreehand::beginPrimaryAction(KoPointerEvent *event){ … initStroke(event);} ... which is adjacent to ->

KisToolFreeHand::doStroke(KoPointerEvent *event) takes in a (KoPointerEvent *event - assuming its the click and drag event )

->KisToolFreehandHelper::paintEvent(KoPointerEvent *event)

• initializes the KisPaintInformation (alot of info + elapsedStrokeTime) and KisUpdateTimeMonitor which reports mouse movement and then calls paint(info)

->KisToolFreehandHelper::paint(KisPaintInformation &info)

• smooths coordinates out using history and the distance. Important to note that pixel tool is using simple smoothing here and that it calls paintBezierSegment inside here. I think right here is when it calculates/gets KisPaintInformation pi1, KisPaintInformation pi2 which is the start and end coordinates of the stroke.

->KisToolFreehandHelper::paintBezierSegment(KisPaintInformation pi1, KisPaintInformation pi2, QPointF tangent1, QPointF tangent2)

• computes and paints a Bezier curve segment between two points. Then it calls paintBezierCurve with the start point, control points, and end points to actually render the bezier curve. (paintBezierCurve(pi1,control1,control2,pi2);) calling without putting the parameter KisDistanceInformation *currentDistance, will call paintBezierCurve again with 0 for the distance.

->KisPaintOp::paintBezierCurve(const KisPaintInformation &pi1, const QPointF &control1, const QPointF &control2, const KisPaintInformation &pi2, KisDistanceInformation *currentDistance)

• Calling this function will call paintBezierCurve again but with a new parameter “this” which is the missing KisPaintOp *paintOp (deals with brush settings)

->KisPaintOp::paintBezierCurve with 1 paintop*

• This function recursively subdivides and paints a cubic Bezier curve segment. It either draws the curve directly if it is sufficiently flat or continues to subdivide the curve until flatness is achieved. When it is sufficient it calls on paintLine

KisBrushOp::paintLine(const KisPaintInformation& pi1, const KisPaintInformation& pi2, KisDistanceInformation *currentDistance)

• handles the painting of a line segment between two points (pi1 and pi2). Depending on specific conditions related to brush sharpness and size, it either performs a custom painting operation or delegates the task to a base class function. If sharpness is on and brush is defined with width and height of 1, we initialize / clear line cache device. Then a KisPainter object p is created with m_lineCacheDevice as its target and painter color gets set and drawDDALine ( Digital Differential Analyzer (DDA) )method gets called on that painter object to draw a line from pi1.pos() to pi2.pos(). Afterwards, the rc is obtained from m_lineCacheDevice->extent() and bitblt gets called on the painter to copy the line from m_lineCacheDevice to the painter’s target canvas. If the sharpness option is not enabled or the brush size does not meet the specified criteria, the function calls KisPaintOp::paintLine(pi1, pi2, currentDistance), which is the base class method for painting a line.

KisPainter::drawDDALine(const QPointF & start, const QPointF & end)

• Plots point based on start and end, but is called so often that it is basically just plotting each individual point when drawing slow strokes.

Second idea is a 3 pixel approach where we track current/lastdrawn/waiting pixel see blog 1 for more info, basically if currentpixel deviates from the x/y axis of lastdrawn pixel we skip over the intermediary waiting pixel. I've been trying this out in kis_brushop where paintLine gets called but the problem with this is that it's difficult to set the three points lastDrawnPixel, currentPixel and waitingPixel when all we have is a bunch of start and end points fed in. I think it is probably possible with some sort of queue system where the points get read slower but there are two problems here, 1.) we might run into a situation where nothing gets drawn until the stroke is let go, and 2.) here in kis_brushop we don't have access to when a stroke ends its only responsible for painting given a start and end point.

The third attempt is to use this somehow to modify the stabilizers to send out proper points so that drawDDALine can automatically make pixel-perfect lines. Still, the problem with this is that if we have a horizontal line straight into a vertical line (and vice versa) the corner where they meet will be non-pixel perfect.

Dear digiKam fans and users,

After five months of active maintenance and long bugs triage, the digiKam team is proud to present version 8.4.0 of its open source digital photo manager.

Long time bugs present in older versions have been fixed and we spare a lot of time to contact users to validate changes in pre-release to confirm fixes before deploying the program in production.

OPC UA client code that relies on hardcoded NodeIds is brittle and often only works with a specific OPC UA server instance. This article shows the proper way to write robust and portable OPC UA client code.

Continue reading OPC UA: Programming against Type Descriptions at basysKom GmbH.

Hi there! The past few weeks have been really busy with my final exams, so I had to slow down my work. Here’s a brief status report on my progress over the past 4 weeks:

I created a SubtitleEvent class to help us better manage subtitle event information, which can replace the original SubtitledTime class. To distinguish subtitles from different layers, I also added basic display support for subtitle layers as multiple subtitle tracks.

Currently, I’m focused on refining these features. There are still some minor tasks to complete and bugs to fix. You can find more information at this MR.

Stay tuned!

I have a very.. unusual notetaking and task setup with Kate, using Orgmode files. I wanted to showcase it and explain how it works, maybe someone else has similar needs.

Here's a small screenshot of my journal notes, I blurred out some things I didn't want to share.

Why OrgMode?

I actually prefer markdown much more. I enjoy writing markdown files and it just works in most editors. However, there is zero markdown note taking apps on android, that allow me to sync from my nextcloud and have notifications.

I write very journal style notes. I have one big journal file (used to be a file per day before), where I write down all the interesting things that happened, plus most importantly, my work tasks.

I tried to use calendar with tasks before.. But theres way too much context switching between notetaking apps, calendars, tasks (and on android you have to have two apps for tasks and calendar!!!). I was drowning in various apps and windows, constantly hopping around..

All I wanted to do was write down a task in my journal, then have that task notify me on my phone and on my desktop whenever it was scheduled.

So eventually I found an app called Orgzly Revived. It lets me take the outline style notes where everything is a bulletpoint, with tasks and such, timers, repeats.. And it has the dang phone notifications no other note taking app has. So it's perfect. Works awesome for my needs.

Only thing is that it requires Orgmode files. Okay, I can do that. I first used Logseq with both markdown and orgmode files, but it's quite slow app, even on my nice PC. And no notifications on mobile of course.

I then realised that I am trying to overcomplicate things. I live a lot of my work life in Kate editor, so I decided to start using that. I had to update the Orgmode Kate syntax file a bit to make it work better for me (it's been upstreamed now yay), but other than that it works really nicely.

And why not Emacs? I need an editor, not an OS. Well, jokes aside, I am just not really into learning yet another tool for something like note taking. Last time I tried to set up Neovim config that works for me, I just ended up doing everything in Kate.. I wager same would happen with emacs. I am very happy with Kate, that's all. And I contribute to it now and then, so it just makes sense to use it. :)

Now I just sync all my note files through my Nextcloud to my phone and my computers. I have couple scripts that make figuring out my agenda and have notifications on my PC as well.

My Kate setup

My setup took some time to get together and with couple scripts and snippets it works pretty well.

• First, you need to git clone https://codeberg.org/akselmo/kate-orgmode.git
  • In there I have couple python and shell scripts, and snippets for Kate
  • You need to create a .venv for it with python -m venv .venv and then pip install -r requirements.txt
  • Check the Readme file for how to use the snippets
• Create session called Notes.
  • In Plasma, you can just search "Notes" in KRunner and open the Notes session, that just opens the files.
• Symlink the org mode snippets to ~/.local/share/ktexteditor_snippets/data/ and make sure they work in Kate
  • Snippets are incredibly powerful in Kate, i recommend using them for many things!
  • These snippets automate stuff like "worktask" entries.
  • Unfortunately any timestamps need to be modified by hand, i have not yet had time to make an external tool that spawns a calendar view and spits out a timestamp.
  • For example, "worktask" adds a following item.

* TODO [#ABC] task_name :work:
SCHEDULED: <2024-07-07 Sun 21:12> DEADLINE: <2024-07-07 Sun 21:12>
  :PROPERTIES:
  :CREATED: [2024-07-07 Sun 21:12]
  :product: product
  :kdebug: [[https://bugs.kde.org/show_bug.cgi?id=bugid][bugid]]
  :merge-request: UPDATE_ME
  :END:

• Add an "external tool" entry for the run-orgagenda.sh item in the files.
  • Set the "Output" setting to "Display in a panel"
  • For the scripts, make sure they're reading right folder (where your notes are)
  • Now you can press ctrl+alt+i and type Org Agenda and it shows you a fun lil overview in a panel of all your items in agenda
• In your DE's autostart, add the run-orgnotifier.sh script.
  • This will send notification for anything you have set as scheduled or deadline before 30 min, and before/after 5 min of the timestamp.

That should be it for the setup, the code for these scripts is absolutely horrid but you should check that all filepaths match yours etc. I need to clean up the code when I feel like it but honestly it Just Works:tm: for now.. lol.

Journaling?

I have one single file that is called Journal-2024 and I create new journal every year. In this journal file, I prepend new items on top of the file, like this.

* Daily notes 2024-07-07
  :PROPERTIES:
  :CREATED:  [2024-07-07 Sun 21:20]
  :END:
Some notes for this day
** Some specific subnote for this daily note
blabla

* TODO [#A] do this task ples :personal:
SCHEDULED: <2024-07-06 Sat 21:22> DEADLINE: <2024-07-07 Sun 21:23>
  :PROPERTIES:
  :CREATED: [2024-07-05 Fri 21:22]
  :END:
blalbla

* DONE [#B] ancient task :work:
  :PROPERTIES:
  :CREATED: [2000-01-01 someDayIdk 21:23]
  :END:
its been 24 years
#+BEGIN_SRC code
ancient code
#+END_SRC

This means that you can just quickly see all the new items. Also in Kate, there's a handy feature for folding all toplevel nodes when you press ctrl+alt+i so you get just list of all headers. I use it all the time. Folding the nodes only works with the newest ksyntaxhighlighting since i recently updated the orgmode syntax file to support that lol.

Anything else

Any other items go to their respective note files.

For example anything related to programming goes to "Programming notes" file. Then I use tags for those items to categorize them based on language, framework, etc..

Instead of having many small files, I have multiple big files, where I categorize items with tags. I can then easily search for items by typing :tag: in the search field in Kate, and it shows me all items related to that tag. Just, well, remember to tag your items! :D

Wrap up

To wrap it up, this system has made things much easier to remember for me, and I can handle more complicated tasks like repeating workout tasks with my phone. (I can do it in Kate too but it requires manual number changing).

I wouldn't mind changing back to markdown if there was a markdown app for phone that has actual notifications.

Sorry this post is a bit all over the place, but there's really not much more interesting things to share about this. It's just couple scripts reminding me or showing all the items in my agenda, and the rest is snippets in Kate and writing orgmode files.

And I am quite happy with my system. Maybe it'll help you to get some ideas too!

Also please tell me about any markdown note taking apps that have notifications on mobile and desktop, if you know any. You can ping me on fedi, which you can find on my about section.

Thanks for reading!

Who am I?

I am Ajay Chauhan (IRC: hisir:matrix.org), currently in my second year of undergraduate studies in Computer Science & Engineering. I'll be working on porting Arianna to Foliate-js for my Google Summer of Code project. I have previously worked on Kdenlive as part of the Season of KDE '24.

I hope to help bring the said feature into reality, but also to sharpen my own development skills through real-world projects, contribute back to the open source community and gain more inner confidence.

What am I working on for this year’s GSoC?

Arianna uses epub.js, which is no longer actively maintained. This creates a challenge as the epub.js may not be able to keep up with the evolving standards and new changes. To address this issue, the proposed solution is to port Arianna to the Foliate-js, which is an actively maintained epub renderer and has more features compared to epub.js and is used by the Foliate ebook reader also.

The problem that this project aims to solve is the need for a reliable and up-to-date epub rendering solution for the Arianna ebook reader. By porting Arianna to Foliate-js, the project will ensure that Arianna can continue to provide support for the latest epub standards and features.

My mentors for the project is Carl Schwan, and I appreciate the opportunity to collaborate with and learn from him during this process.

My work done so far

Setting up the development environment

First step was to setup the dev environment, I used Qt Creator for that, it’s fairly easy to set up the development environment.

Reading through existing codebase

The journey began with a thorough review of the existing implementation of epub.js (epub-viewer.js) in Arianna. I identified the features and functionalities that needed to be ported to Foliate-js, understanding how epub.js was used in Arianna for rendering, navigation, and user interactions, and the C++ backend code.

Next, I focused on identifying all the places where epub.js was integrated with Qt in Arianna. This involved comparing the existing implementation with Foliate-js's approach to implementing the same features. To document the changes, I prepared a draft merge request.

Familiarised myself with the current Foliate reader implementation of the foliate-js. However, challenging for me to understand the backend architecture and how different components are interconnected within Foliate-js, requiring additional time to fully grasp the codebase.

Implementing changes

• Fixing the tricky part of the loading process. I had a hard time wrapping my head around how all the pieces fit together. My mentor helped me in this.

Implemented Table of Contents (TOC) functionality:

const { book } = action.payload;
if (book && book.toc) {
  applicationWindow().contextDrawer.model.importFromJson(
    JSON.stringify(book.toc)
  );
} else {
  console.warn("Book or TOC not available");
}

It takes the TOC data from the book and imports it into the app's context drawer. This way, users can easily access and navigate through the book's structure.

Added metadata handling:

const metadata = action.payload.book.metadata;
if (metadata) {
  backend.metadata = metadata;
  root.bookReady(backend.metadata.title);
  Database.addBook(backend.file, JSON.stringify(metadata));
}

Let me break down what this does:

• First, it grabs the metadata from the book that's been loaded.
• If there's metadata, it does a few important things:
  • Updates the backend with this new info.
  • Tells the app that the book is ready to go, passing along the title.
  • Stores all this metadata in the database.

What’s next?

In the following weeks of GSoC, I plan to first to focus on tackling the rendition setup. This is a crucial step - it's what will allow our ebook reader to display the content of ebooks correctly, and also setting the style for the reader. This will involve integrating the Foliate-js rendition module with Arianna's Qt implementation.

Thanks for your reading, stay tuned for updates on my progress via my blog and feel free to connect with me.

强制类型转换

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
}

详细

Lambda表达式

匿名函数是很多高级语言都支持的概念，如lisp语言在1958年首先采用匿名函数。匿名函数有函数体，但没有函数名。C++11中引入了lambda表达式。利用lambda表达式可以编写内嵌的匿名函数，用以替换独立函数或者函数对象，并且使代码更可读。但是从本质上来讲，lambda表达式只是一种语法糖，因为所有其能完成的工作都可以用其它稍微复杂的代码来实现。但是它简便的语法却给C++带来了深远的影响。如果从广义上说，lamdba表达式产生的是函数对象。

相同类似功能我们也可以使用函数对象或者函数指针实现：函数对象能维护状态，但语法开销大，而函数指针语法开销小，却没法保存范围内的状态。lambda表达式正是结合了两者的优点。

声明Lambda表达式

1
2
3
4
5
6
7

// 完整语法
[capture list] (params list) mutable(optional) constexpr(optional)(c++17) exception attribute -> return type { function body };

// 可选的简化语法
[capture list] (params list) -> return type {function body};  //1
[capture list] (params list) {function body};//2
[capture list] {function body};//3

• capture list：捕获外部变量列表，不能省略；
• params list：形参列表，可以省略（但是后面必须紧跟函数体）；
• mutable指示符： 可选，将lambda表达式标记为mutable后，函数体就可以修改传值方式捕获的变量；
• constexpr：可选，C++17，可以指定lambda表达式是一个常量函数；
• exception：异常设定， 可选，指定lambda表达式可以抛出的异常；
• attribute：可选，指定lambda表达式的特性；
• return type：返回类型
• function body：函数体

标号1. 函数声明了一个const类型的表达式，此声明不可改变capture list中的捕获的值。

标号2. 函数省略了返回值，此时如果function body内含有return语句，则按return语句返回类型决定返回值类型，若无则返回值为void类型。

标号3. 函数无参数列表，意味无参函数。

1
2
3

vector<int> vec{1,0,9,5,3,3,7,8,2};

sort(lbvec.begin(), lbvec.end(), [](int a, int b) -> bool { return a < b; });  

捕获外部变量

lambda表达式最前面的方括号的意义何在？其实这是lambda表达式一个很Hong要的功能，就是闭包。这里我们先讲一下lambda表达式的大致原理：每当你定义一个lambda表达式后，编译器会自动生成一个匿名类（这个类当然重载了()运算符），我们称为闭包类型（closure type）。那么在运行时，这个lambda表达式就会返回一个匿名的闭包实例，其实一个右值。所以，我们上面的lambda表达式的结果就是一个个闭包。闭包的一个强大之处是其可以通过传值或者引用的方式捕捉其封装作用域内的变量，前面的方括号就是用来定义捕捉模式以及变量，我们又将其称为lambda捕捉块。

Lambda表达式可以捕获外面变量，但需要我们提供一个谓词函数（[capture list]在声明表达式最前）。类似参数传递方式：值传递、引入传递、指针传递。在Lambda表达式中，外部变量捕获方式也类似：值捕获、引用捕获、隐式捕获。

值捕获

1
2
3
4
5

int a = 123;
auto f = [a] { cout << a << endl; }; 
f(); // 输出：123
a = 321;
f(); // 输出：123

值捕获和参数传递中的值传递类似，被捕获的值在Lambda表达式创建时通过值拷贝的方式传入，类中会相应添加对应类型的非静态数据成员。在运行时，会用复制的值初始化这些成员变量，从而生成闭包。因此Lambda表达式函数体中不能修改该外部变量的值； 因为函数调用运算符的重载方法是const属性的。同样，函数体外对于值的修改也不会改变被捕获的值。 想改动传值方式捕获的值，那么就要使用mutable。

1
2
3

auto add_x = [x](int a) mutable { x *= 2; return a + x; };  // 复制捕捉x
    
cout << add_x(10) << endl; // 输出：30

因为一旦将lambda表达式标记为mutable，那么实现的函数调用运算符是非const属性的。

引用捕获

1
2
3
4

int a = 123;
auto f = [&a] { cout << a << endl; }; 
a = 321;
f(); // 输出：321

引用捕获的变量使用的实际上就是该引用所绑定的对象，因此引用对象的改变会改变函数体内对该对象的引用的值。 对于引用捕获方式，无论是否标记mutable，都可以在lambda表达式中修改捕获的值。

隐式捕获

隐式捕获有两种方式，分别是 [=]：以值补获的方式捕获外部所有变量 [&]：表示以引用捕获的方式捕获外部所有变量。

1
2
3

int a = 123, b=321;
auto df = [=] { cout << a << b << endl; };    // 值捕获
auto rf = [&] { cout << a << b << endl; };    // 引用捕获

其他

既然只使用一次，那直接写全代码不就行了，为啥要函数呢？——因为lambda可以捕获局部变量

在上面的捕获方式中，注意最好不要使用[=]和[&]默认捕获所有变量。首先说默认引用捕获所有变量，你有很大可能会出现悬挂引用（Dangling references），因为引用捕获不会延长引用的变量的声明周期：

1
2
3
4

std::function<int(int)> add_x(int x)
{
return [&](int a) {return x+a;};
}

因为参数x仅是一个临时变量，函数调用后就被销毁，但是返回的lambda表达式却引用了该变量，但调用这个表达式时，引用的是一个垃圾值，所以会产生没有意义的结果。如果通过传值的方式来解决上面的问题：

1
2
3
4

std::function<int(int)> add_x(int x)
{
    return [=](int a) { return x + a; };
}

使用默认传值方式可以便面悬挂引用问题.但是采用默认值捕获所有变量仍然有风险。例如当在类中捕获私有变量，当返回值为lambda表达式时，无法捕获到私有变量，但当指定为[=]时，会捕获到this指针的副本，当类已经调用析构函数，使用该指针仍然不安全.

参数

• 参数列表中不能有默认参数
• 不支持可变参数
• 所有参数必须要参数名（相当于不可以有占位参数）

返回类型

单一的return语句可以推断返回类型；多语句则默认返回void，否则报错，应指定返回类型

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

// 正确，单一return语句
transform(vi.begin(),vi.end(),vi.begin(), 
    [] (int i) { 
    return i<0? -i; i;
    }
);
// 错误。不能推断返回类型
transform(vi.begin(),vi.end(),vi.begin(), 
    [] (int i) { 
        if (I<0) return -i;
        else return i;
    }
);
// 正确，尾置返回类型
transform(vi.begin(),vi.end(),vi.begin(), 
    [] (int i) ->int{ 
        if (I<0) 
            return -i;
        else 
            return i;
    }
);

赋值

auto和function可接受lambda表达式的返回：

1
2
3

int x =8,y=9;
auto add = [](int a,int b){return a+b;};
std::function<int(int,int)> Add = [=] (int a,int b){return a+b};

lambda表达式产生的类不含有默认构造函数、赋值运算符、默认析构函数。至于闭包类中是否有对应成员，C++标准中给出的答案是：不清楚的，看来与具体实现有关。还有一点要注意：lambda表达式是不能被赋值的：

1
2
3
4
5

auto a = [] { cout << "A" << endl; };
auto b = [] { cout << "B" << endl; };

a = b;   // 非法，lambda无法赋值
auto c = a;   // 合法，生成一个副本

因为禁用了赋值操作符：

1

ClosureType& operator=(const ClosureType&) = delete;

但是没有禁用复制构造函数，所以可以用一个lambda表达式去初始化另外一个lambda表达式而产生副本。并且lambda表达式也可以赋值给相对应的函数指针，这也使得你完全可以把lambda表达式看成对应函数类型的指针。

新特性

在C++14中，lambda又得到了增强，一个是泛型lambda表达式，一个是lambda可以捕捉表达式。

lambda捕捉表达式

lambda表达式可以按复制或者引用捕获在其作用域范围内的变量。而有时候，我们希望捕捉不在其作用域范围内的变量，而且最重要的是我们希望捕捉右值。所以C++14中引入了表达式捕捉，其允许用任何类型的表达式初始化捕捉的变量：

1
2
3
4
5
6
7
8

// 利用表达式捕获，可以更灵活地处理作用域内的变量
int x = 4;
auto y = [&r = x, x = x + 1] { r += 2; return x * x; }();
// 此时 x 更新为6，y 为25

// 直接用字面值初始化变量
auto z = [str = "string"]{ return str; }();
// 此时z是const char* 类型，存储字符串 string

可以看到捕捉表达式扩大了lambda表达式的捕捉能力，有时候你可以用std::move初始化变量。这对不能复制只能移动的对象很重要，比如std::unique_ptr，因为其不支持复制操作，你无法以值方式捕捉到它。但是利用lambda捕捉表达式，可以通过移动来捕捉它：

1
2
3
4

auto myPi = std::make_unique<double>(3.1415);

auto circle_area = [pi = std::move(myPi)](double r) { return *pi * r * r; };
cout << circle_area(1.0) << endl; // 3.1415

原文章