Friday, 29 March 2024

shell

主函数

先创建一个Shell类型的类
然后屏蔽信号ctrl+c与ctrl+D
接着打印提示符，接收命令的输入
判断该次命令是否含有exit clear !等信息，如果有，执行相应操作
通过调用解析函数解析本次输入的命令

屏蔽信号

ctrl + C

1	signal(SIGINT, SIG_IGN);//将该信号的处理方式设置为忽略

ctrl + D

struct termios term;
   tcgetattr(STDIN_FILENO, &term);
   term.c_cc[VEOF] = _POSIX_VDISABLE;
   tcsetattr(STDIN_FILENO, TCSANOW, &term);

首先定义一个termios类型的结构体，用来存储终端相关的属性信息
然后通过调用tcgetattr函数将获取终端的相关属性，并将这些属性保存到 **term **结构体中，第一个参数表示标准输入，是一个预定的文件描述符常量
将结构体中的c_cc数组成员的VEOF设置为禁用. c_cc数组是包含终端特殊字符的数组，VEOF是其中的一个索引，第二个参数是一个特殊的宏，用于禁用该特殊字符
最后，tcsetattr(STDIN_FILENO, TCSANOW, &term);调用tcsetattr()函数，它用于设置终端的属性。STDIN_FILENO表示标准输入文件描述符，TCSANOW表示立即生效的选项，&term是要设置的终端属性结构体。

tcgetattr

1	int tcgetattr(int fd, struct termios *termios_p);

参数说明：

fd 是一个打开的终端设备文件描述符。
termios_p 是一个指向 termios 结构体的指针，用于存储获取
到的终端属性。

tcgetattr 函数返回一个整数值，表示函数调用的成功与否。如果函数成功执行，返回值为0；如果出现错误，返回值为-1，并设置相应的错误码。在调用该函数时，你需要检查返回值以确保函数调用是否成功。

tcsetattr

1	int tcsetattr(int fd, int optional_actions, const struct termios *termios_p);

参数说明：

fd 是一个打开的终端设备文件描述符。
optional_actions 是一个表示操作选项的整数值，用于指定何时应用属性的更改。
termios_p 是一个指向 termios 结构体的指针，其中包含了要应用的终端属性。

optional_actions 参数用于指定何时应用属性的更改，它可以取以下三个值之一：

TCSANOW：立即更改属性。
TCSADRAIN：在所有输出都被传输后更改属性。
TCSAFLUSH：在所有输出都被传输后更改属性，并丢弃所有未读的输入。

print

getlogin

1 2	char* getlogin(void) //返回一个指向当前登陆用户的用户名的字符串指针

strcspn

size_t strscpn(const char *str1,const char *str2);
//str1：要搜索的字符串
//str2：要查找的字符集合
//计算字符串中连续不包含指定字符集合的最大前缀长度。

strftime

1	size_t strftime(char str, size_t maxsize, const char format, const struct tm *timeptr);

参数说明：

str 是一个指向字符数组的指针，用于存储格式化后的时间字符串。
maxsize 是 str 所指向的字符数组的最大容量。
format 是一个格式字符串，用于定义输出的时间格式。
timeptr 是一个指向 struct tm 结构体的指针，其中包含要格式化的时间和日期。

chrono::system_clock::now();
//是c++<chrono>头文件中的一个函数调用，用于获取当前的系统时间点
chrono::system_clock::to_time_t
//是一个函数模板，将time_point对象转换为time_t的类型

mycd

getenv

1	char* getenv(const char* name);

参数说明:

name是一个指向以null结尾的字符串，表示要获取的环境变量的名称.

根据指定的环境变量的名称，返回对应的环境变量的值。找到则返回一个null结尾的字符串，表示该环境变量的值.否则返回null.

1 2	const char* path = s[1].c_str(); //将string对象转换为c风格的字符串.

需要注意的是c_str()返回的指针指向的仍为string内部存储的字符数组，因此需要确保在使用path指针时，string对象仍然有效

get_current_dir_name

是一个标准的POSIX函数，用于获取当前工作目录的路径

由于get_current_dir_name( )分配了动态内存，因此使用完毕后需要调用free( )。

setenv

1	int setenv(const char* name, const char* value, int overwrite);

参数说明：

name 是一个指向以 null 结尾的字符串，表示要设置或新建的环境变量的名称。
value 是一个指向以 null 结尾的字符串，表示要设置的环境变量的值。
overwrite 是一个整数值，指示在环境变量已经存在时是否进行覆盖。如果 overwrite 为非零值，则会覆盖现有环境变量；如果 overwrite 为零，则不进行覆盖。

parse

istringstream是C++标准库中的一个类，他是用于从字符串中进行输入操作的输入流类.

getline()

1	std::istream& getline(std::istream& is, std::string& str, char delim);

参数说明：

is 是一个输入流对象，表示要从中读取文本的输入流，通常是 std::cin（标准输入）或文件流对象。
str 是一个字符串对象的引用，表示读取的文本将存储在其中。
delim 是一个字符（默认为换行符 \n），表示行的结束符。

pipe

“pipe”（管道）是一种在进程间进行通信的机制。它允许一个进程的输出直接成为另一个进程的输入，从而实现进程间的数据传输。

匿名管道：
- 匿名管道是最常见的管道类型。它是一种单向通信管道，只能在具有父子关系的进程之间使用。父进程创建管道后，可以通过文件描述符进行读取或写入。子进程继承了父进程的文件描述符，从而可以使用相反的操作进行读取或写入。
- 匿名管道是一种半双工通信方式，即数据只能在一个方向上流动。如果需要双向通信，需要创建两个匿名管道。
- 使用匿名管道的典型流程是：父进程创建管道，然后调用 fork() 创建子进程。父进程关闭不需要的管道端口，子进程关闭另一个不需要的端口。然后父进程可以向管道写入数据，子进程可以从管道读取数据。
命名管道：
- 命名管道也称为FIFO（First-In-First-Out），它提供了一种无关进程关系的进程间通信方式。命名管道在文件系统中有一个与之相关联的路径名，多个进程可以通过这个路径名来进行通信。
- 命名管道是一种半双工通信方式，类似于匿名管道，只能在一个方向上流动数据。
- 命名管道可以使用 mkfifo 函数创建，也可以使用命令行工具 mkfifo 创建。

管道的使用可以通过系统调用函数来实现，例如 POSIX 标准中的 pipe() 函数。在使用管道时，重要的是要了解管道的读取和写入端口以及数据的流动方向，以确保正确的通信。

1	int pipe(int pipefd[2]);

pipe() 函数接受一个整型数组 pipefd[2]，用于存储管道的文件描述符。pipefd[0] 表示管道的读取端口，pipefd[1] 表示管道的写入端口。该函数返回值为 0 表示成功，-1 表示失败。
以下是 pipe() 函数的详细解释：
pipefd 参数是一个包含两个元素的整型数组，用于存储管道的文件描述符。pipefd[0] 是管道的读取端口，用于从管道中读取数据；pipefd[1] 是管道的写入端口，用于向管道中写入数据。
pipe() 函数创建一个匿名管道，并将管道的读取端口和写入端口的文件描述符填充到 pipefd 数组中。
匿名管道是一种半双工通信方式，数据只能在一个方向上流动。如果需要双向通信，需要创建两个匿名管道。
管道是内核中的一个缓冲区，用于在相关进程之间传输数据。数据写入管道后，可以从管道的读取端口读取。
管道的大小是有限的，一旦管道的缓冲区满了，进程写入数据时可能会被阻塞，直到有足够的空间来容纳数据。同样，如果管道为空，从管道读取数据时可能会被阻塞，直到有数据可读。
如果一个进程关闭了管道的读取端口，而另一个进程关闭了管道的写入端口，这两个进程之间的管道通信将结束。

dup2

1
2
3

#include <unistd.h>

int dup2(int oldfd, int newfd);

oldfd 参数是需要复制的文件描述符。它可以是任何有效的文件描述符，包括标准输入（0）、标准输出（1）和标准错误（2）。
newfd 参数是要复制到的新文件描述符。如果 newfd 已经打开，则会先关闭它，然后将 oldfd 复制到 newfd。
复制后，newfd 将和 oldfd 指向相同的文件表项，它们共享同一个文件偏移量和文件状态标志。
如果 newfd 等于 oldfd，则 dup2() 函数不进行任何操作，直接返回 newfd。
dup2() 函数的一个常见用途是重定向标准输入、标准输出和标准错误。例如，可以将标准输出重定向到一个文件，或者将标准错误重定向到一个套接字。

executeCommand

open

command[i + 1].c_str()：command是一个字符串向量，command[i + 1]表示该向量中的第i + 1个元素。.c_str()将该元素转换为C风格的字符串，以便与open()函数的参数类型匹配。这个参数是要打开的文件的路径。
O_WRONLY：是open()函数的一个打开模式，表示以只写方式打开文件。这意味着你可以向文件写入数据，但不能读取文件的内容。
O_CREAT：是open()函数的一个打开模式，表示如果文件不存在，则创建该文件。如果文件已经存在，open()函数仍然会成功打开文件。
O_TRUNC：是open()函数的一个打开模式，表示如果文件已经存在且以只写方式打开，那么在打开文件时将截断文件的长度为0。这意味着打开文件后，文件中已经存在的内容将被清空。
0644：表示文件的权限。在这里，0644表示文件所有者具有读和写的权限，而其他用户只有读的权限。它是一个八进制数，其中第一个数字0表示这是一个八进制数，后面的三个数字分别表示文件所有者、文件所属组和其他用户的权限。

代码

shepp.hpp

#include <iostream>
using namespace std;
#include <string>
#include <vector>
#include <sstream>
#include <chrono>
#include <unistd.h>
#include <csignal>
#include <algorithm>
#include <termios.h>
#include <cstdlib>
#include <wait.h>
#include <fstream>
#include <sys/stat.h>
#include <fcntl.h>

class Shell
{
public:
    void print();
    void setlinebuf();
    string retlinebuf();
    void setsignal();
    bool isempty();
    void addHistory(const string& line);
    void setEOF();
    void printHistory();
    void searchAndReplay(const string &keyword);
    void mycd(vector<string> &s);
    void executeCommand(const vector<string> &command);
    void parse(string &s);
private:
    string linebuf;
    vector<string> history;
};

func.cpp

#include "shell.hpp"

void Shell::print()
{   cout << "----------------------------------------------------------------------------" << endl;
    cout << "           ___                                                     ___" << endl;
    cout << "  ______  /  /___       ______  _____  ___   ___       ____  _____/  /___" << endl;
    cout << " /  __  \\/  __   \\     /  ___ - ___  \\/  /  /  /     /_   / /  __/  __   \\" << endl;
    cout << "/  /_/  /  /  /  /    /  /  /  /  /  /  /__/  /       /  /_(__  )  /  /  /" << endl;
    cout << "\\______/__/  /__/    /__/  /__/  /__/\\____,  /       /____/____/__/  /__/" << endl;
    cout << "                                    /_______/" << endl;
    cout << "----------------------------------------------------------------------------" << endl;
    char cwd [1024];
    auto now = chrono::system_clock::now();//返回当前的时间
    time_t time = chrono::system_clock::to_time_t(now);//将time_t point转换为time_t类型
    tm* timeinfo = std::localtime(&time);//将time_t转换为本地时间年月日,并存储在timeinfo中
    char timeStr[9];
    strftime(timeStr, sizeof(timeStr), "%H:%M:%S", timeinfo);
    //std::strftime()将std::tm结构的时间信息格式化为字符串，并将结果存储在指定的字符数组中。这里使用"%H:%M:%S"作为格式字符串
    //，它表示小时、分钟和秒的格式。timeStr是目标字符数组，sizeof(timeStr)用于指定数组的大小，
    //timeinfo是包含时间信息的std::tm结构的指针。
    cout << "# future @ future-arch in " << getcwd(cwd,1024) << " [" << timeStr << "]" << endl;
    cout << "$ " ;
    fflush(stdout);
}

void Shell ::setlinebuf()
{
    getline(cin,this->linebuf);
}

string Shell::retlinebuf ()
{
    return this->linebuf;
}

void Shell:: setsignal()
{
    signal(SIGINT, SIG_IGN);//忽略ctrl+c的操作
}

bool Shell ::isempty() 
{
    if(this->linebuf.empty())
    {
        return true;
    }
    return false;
}

void Shell::addHistory(const string& line)
{
    for(vector<string>::iterator it = history.begin(); it != history.end();it++)
    {
        if((*it).compare(line) == 0)
        return ;
    }
    history.push_back(line);
}

void Shell ::setEOF()
{
    struct termios term;//存储终端的相关信息
    tcgetattr(STDIN_FILENO, &term);//获取相关信息，并存入结构体
    term.c_cc[VEOF] = _POSIX_VDISABLE;//禁止使用EOF
    tcsetattr(STDIN_FILENO, TCSANOW, &term);//将设置存入终端
}

void Shell::printHistory()
{
    for(vector<string>::iterator it = this->history.begin(); it != this->history.end();it++)
    {
        cout << *it << endl;
    }
    cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~"<< endl;
}

void Shell::searchAndReplay(const string& keyword)
{
    for (const string& line : history)
    {
        if (line.find(keyword) != string::npos)
        {
            cout << "Replaying: " << line << endl;
            linebuf = line;
            break;
        }
    }
}

void Shell::parse(string& s)
{
    vector<vector<string>> tokens;
    istringstream iss(s);//可方便的从字符串中读取数据
    string root;
    while (getline(iss, root, '|'))//将s以|分割开
    {
        istringstream root_iss(root);
        vector<string> root_tokens;
        string token;
        while (root_iss >> token)//将单个命令以空格分隔开
        {
            root_tokens.push_back(token);
        }

        tokens.push_back(root_tokens);
    }
    if (tokens.size() == 1)
    {
        vector<string>& command = tokens[0];
        if (command[0] == "cd")
        {
            mycd(command);
        }
        else
        {
            executeCommand(command);
        }
    }
    else if (tokens.size() > 1)
    {
        int numPipes = tokens.size() - 1;
        vector<int> pipefds(2 * numPipes, 0); // 用于存储管道的文件描述符
        for (int i = 0; i < numPipes; ++i)
        {
            if (pipe(pipefds.data() + i * 2) < 0)
            {
                perror("pipe()");
                exit(1);
            }
        }
        int commandIndex = 0;
        for (auto& command : tokens)
        {
            pid_t pid = fork();
            if (pid < 0)
            {
                perror("fork()");
                exit(1);
            }
            if (pid == 0)
            {
                // 子进程
                if (commandIndex != 0) // 不是第一个命令，读取前一个管道的输出
                {
                    if (dup2(pipefds[(commandIndex - 1) * 2], STDIN_FILENO) < 0)
                    {
                        perror("dup2()");
                        exit(1);
                    }
                }
                if (commandIndex != numPipes) // 不是最后一个命令，将输出写入下一个管道
                {
                    if (dup2(pipefds[commandIndex * 2 + 1], STDOUT_FILENO) < 0)
                    {
                        perror("dup2()");
                        exit(1);
                    }
                }
                // 关闭所有管道的文件描述符
                for (int i = 0; i < 2 * numPipes; ++i)
                {
                    close(pipefds[i]);
                }
                if (command[0] == "cd")
                {
                    mycd(command);
                }
                else
                {
                    executeCommand(command);
                }

                exit(0);
            }
            else
            {
                // 父进程
                ++commandIndex;
            }
        }
        // 关闭所有管道的文件描述符
        for (int i = 0; i < 2 * numPipes; ++i)
        {
            close(pipefds[i]);
        }

        // 等待所有子进程结束
        for (size_t i = 0; i < tokens.size(); ++i)
        {
            wait(NULL);
        }
    }
}

void Shell::mycd(vector<string>& s)
{
    if (s.size() > 2)
    {
        cout << "cd: 函数调用参数过多" << endl;
        return;
    }
    else if (s.size() == 1 || s[1].compare("~") == 0)
    {
        const char* homeDir = getenv("HOME");
        if (homeDir)
        {
            if (chdir(homeDir) == -1)
            {
                perror("chdir()");
            }
        }
        else
        {
            cout << "cd: 无法获取家目录路径" << endl;
            return;
        }
    }
    else if (s[1].compare("-") == 0)
    {
        const char* lastDir = getenv("OLDPWD");
        if (lastDir)
        {
            if (chdir(lastDir) == -1)
            {
                perror("chdir()");
            }
        }
        else
        {
            cout << "cd: 无法找到上一个路径" << endl;
        }
    }
    else
    {
        const char* path = s[1].c_str();
        if (chdir(path) == -1)
        {
            perror("chdir()");
        }
    }
    // 更新环境变量 OLDPWD
    char* currentDir = get_current_dir_name();//获取当前工作目录的路径
    if (currentDir)
    {
        if (setenv("OLDPWD", currentDir, 1) == -1)//设置环境变量
        {
            perror("setenv()");
        }
        free(currentDir);
    }
    else
    {
        perror("get_current_dir_name()");
    }
}

void Shell::executeCommand(const vector<string>& command)
{
    pid_t pid;
    fflush(NULL);
    pid = fork();
    if (pid < 0)
    {
        perror("fork()");
    }
    if (pid == 0)
    {
        vector<char*> args;
        vector<int> outputFds; // 存储输出文件描述符的容器

        for (size_t i = 0; i < command.size(); ++i)
        {
            if (command[i] == ">") // 输出重定向：覆盖写入文件
            {
                int fd = open(command[i + 1].c_str(), O_WRONLY | O_CREAT | O_TRUNC, 0644);
                if (fd == -1)
                {
                    perror("open()");
                    exit(1);
                }
                outputFds.push_back(fd); // 将新的文件描述符添加到容器中
                dup2(fd, STDOUT_FILENO);
                close(fd);
                i++;
            }
            else if (command[i] == ">>") // 输出重定向：追加写入文件
            {
                int fd = open(command[i + 1].c_str(), O_WRONLY | O_CREAT | O_APPEND, 0644);
                if (fd == -1)
                {
                    perror("open()");
                    exit(1);
                }
                outputFds.push_back(fd); // 将新的文件描述符添加到容器中
                dup2(fd, STDOUT_FILENO);
                close(fd);
                i++;
            }
            else if (command[i] == "<") // 输入重定向
            {
                int fd = open(command[i + 1].c_str(), O_RDONLY);
                if (fd == -1)
                {
                    perror("open()");
                    exit(1);
                }
                dup2(fd, STDIN_FILENO);
                close(fd);
                i++;
            }
            else if (command[i] == "<<") // Here文档
            {
                string delimiter = command[i + 1];
                string inputText;

                while (getline(cin, inputText))
                {
                    if (inputText == delimiter)
                        break;
                    inputText += "\n";
                    write(STDIN_FILENO, inputText.c_str(), inputText.size());
                }

                i++;
            }
            else
            {
                args.push_back(const_cast<char*>(command[i].c_str()));
            }
        }

        args.push_back(nullptr); // execvp 需要以 nullptr 结尾的参数数组
        execvp(args[0], args.data());

        // execvp 执行失败时才会执行到这里
        perror("execvp()");
        exit(1);
    }
    else
    {
        wait(NULL);
    }
}

shell.cpp

#include "func.cpp"

int main()
{
    int num = 1;
    Shell mysh;
    mysh.setsignal();   
    mysh.setEOF();
    while(num)
    {
        mysh.print();
        mysh.setlinebuf();
        string t = mysh.retlinebuf();
        if(t.empty())
        {
            cout << "No input" << endl;
        }
        else if(t.rfind("exit")!=string::npos)
        {
            break;
        }
        else if(t.find("!")==0)
        {
            string keyword = t.substr(1); //获取去除感叹号的关键字
            mysh.searchAndReplay(keyword);
        }
        else if(t.find("clear")==0)
        {
            mysh.addHistory(t);
            // cout << "\033[2J\033[1;1H";//通过转义序列清除终端，但只能清楚当次的命令
            system("clear");
            num++;
        }
        else
        {
            mysh.addHistory(t);
            num++;
        }
        mysh.parse(t);
        if(num%3==0)
        {
            cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~"<< endl;
            cout << " History Order :" << endl;
            mysh.printHistory();
        }
    }
    return 0;
}

后续问题：

在输入命令全为空格的时候，会直接推出程序，造成程序崩溃.
1. 是在parse中解析命令的时候，由于全为空格，所以会将一个空字符串token放入命令数组tokens,导致tokens.size()不为0造成exec函数的执行出现错误
2. 所以在开始解析命令的时候加上全为空格的判断.
  1
  2
  3
  4
  if(std::all_of(s.begin(),s.end(),::isspace))
  {
  return {};
  }
3. 在全为空格的时候直接返回，这样就可以返会空的二维数组.
缺乏对乱码命令的提示:例如输入”djsakldjalkjsduj”，等命令没有类似zsh : command not found : jdklasjdlak的提示，而是由于exec函数的无法执行出现的提示.
对于主题打印的提示，可以将Oh my zsh的打印只放在初始的时候，而不是每一次都打印.
另外在输出主机名称时，输出的是固定的作者的主机名称，这里为了偷懒，未使用gethostname()来获取主机名.
可以考虑对命令的存储进行改进，运用其他的结构存储，而不是二维数组.
增加类与类之间的联系，而不是简单的创造一个类，这样的话就只是相当于类似头文件的作用，并没有过多的用到一些c++的特性之类的东西.

Wednesday, 27 March 2024

KTextAddons 1.5.4 🔗

KDE Release Team 00:00 +00:00

RSS

KTextAddons 1.5.4 is a bugfix release of our text display and handling library

It fixes two notable bugs and updates translations

Fix bug 484328: Kmail config dialog takes about 40 seconds to show up
Use QListView::clicked (in emoji popup menu)

URL: https://download.kde.org/stable/ktextaddons/
Source: ktextaddons-1.5.4.tar.xz
SHA256: 64b80602e84b25e9164620af3f6341fa865b85e826ab8f5e02061ae24a277b20
Signed by: E0A3EB202F8E57528E13E72FD7574483BB57B18D Jonathan Esk-Riddell jr@jriddell.org https://jriddell.org/esk-riddell.gpg

Saturday, 23 March 2024

Using the QML Language Server for KDE Development 🔗

Nicolas Fella

nicofee 13:00 +00:00

Atom

For a while Qt has been offering qmlls, a Language Server Protocol implementation for QML. This allows popular text editors like Kate (and some lesser known ones like Visual Studio Code) to work with QML code without having to write dedicated support for it.

Naturally many people are eager to use it to hack on KDE code. When trying to do that you probably have encountered some frustration with things not working as expected. So what’s going on there, and how can we make it work?

First and foremost one must mention that qmlls is still under heavy development. There’s a number of things missing that you’d expect from a fully featured LSP implementation. If you encounter something that looks like it should work but doesn’t, don’t hesitate to file a bugreport.

So how does one use qmlls? In Kate it should be activated out-of-the-box when opening a QML file. If that doesn’t work you might need to tweak the LSP-Client settings. For other editor please consult their documentation on how to enable LSP support.

One problem you are likely to encounter when using qmlls on KDE code is that it fails to find KDE-provided QML modules like Kirigami. This happens when the modules are installed into e.g. ~/kde/usr, which isn’t searched by Qt. One way to get around this is to build and install your own Qt into ~/kde/usr too, since that way the modules will be installed into the same prefix as Qt and Qt will find them. While building your own Qt is a worthwile thing to do in general it’s not a very satisfying solution. I hope we can find a better solution for this soon. See here for a related bugreport.

If your installation is set up in a way that qmlls can find the KDE-provided modules you might still encounter it warning on unknown modules or types. In order for qmlls to show information for a module the module needs a qmltypes file. These files provide machine-readable information about the types that the module exposes. The easiest way to make these available is porting the module to ecm_add_qml_module and declarative type registration. This was done for many KDE modules already, but there’s still a number of them missing. Help on that is very welcome! Something that isn’t obvious is that in order for the tooling to work correctly module dependencies need to be marked explicity via the DEPENDENCIES parameter in ecm_add_qml_module.

If all the modules and types are found correctly you will still encounter some warnings, but most of these should correspond to actual issues and non-optimal practices like using unqualified property lookups and context properties. qmlls is a great tool to guide you towards resolving those and thus modernizing and optimizing the code. There are however some classes of warnings for which we don’t have proper solutions yet:

Our translation functions, i18n and friends, are considered unqualified lookups by qmllint/qmlls. This is because they are magically injected into the engine at runtime. It’s not clear how a solution for this could look like.
When writing KCMs we expose the module’s C++ class via the kcm context property, which is opaque to the tools. A different approach is needed.

Despite the current limitations qmlls is already a very useful tool for working on QML code, assuming the project is set up properly.

Happy QML hacking!

If you are reading this from the future there’s an update available.

Wednesday, 20 March 2024

Trusting content on the KDE Store 🔗

David Edmundson 10:59 +00:00

RSS

Recent events

A global theme on the kde third party store had an issue where it executed a script that removed user's data. It wasn't intended as malicious, but a mistake in some shell parsing. It was promptly identified and removed, but not before doing some damage to that user.

This has started a lot of discourse around the concept of the store, secuirty and upstream KDE. With the main question how can a theme have access to do this?

To developers it's not a surprise that third party plugins can do this sort of thing. It's as intended. A global theme can ship custom lockscreens, custom applets, custom settings and all of these can run arbitrary bundled code. You can't constrain this without limiting functionality.

To that end there's an explicit warning when downloading plugins.

Expectations

Our primary issue boils down to expectation management and communication.

There are plenty of other ways where users can download and run any other unfettered code from the internet; the Arch user repository (AUR), adding ubuntu PPAs and alike. This isn't a bad thing - it's useful and people do amazing things with this to benefit users.

Nothing on the KDE store happens without explicit user interaction either.

A problem is there's an expectation that because it's programs that it's inherently unsafe and a user needs to trust the source. Our issue is phrases like "global themes" or "Plasma applets" don't always carry this message.

The tech world has changed a lot over the past decade and whilst our code hasn't changed, users expectations have. More and more places provide well kept walled gardens where most actions accessible via the UI are safe-by-default - or at least claim to be!

I've also seen confusion that because a lot of our UI is written in a higher-level language (QML) that's enriched with javascript all browser sandboxing automatically applies. Even though that's not what we claim.

But ultimately if there is a gap in expectations, that's on us to fix.

What can we do better?

In the short term we need to communicate clearly what security expectations Plasma users should have for extensions they download into their desktops. Applets, scripts and services, being programs, are easily recognised as potential risks. It's harder to recognise that Plasma themes, wallpaper plugins and kwin scripts are not just passive artwork and data, but may potentially also include scripts that can have unintended or malicious consequences.

We need to improve the balance of accessing third party content that allows creators to share and have users to get this content easily, with enough speed-bumps and checks that everyone knows what risks are involved.

(UI from Flathub for potentially unsafe content)

Longer term we need to progress on two avenues. We need to make sure we separate the "safe" content, where it is just metadata and content, from the "unsafe" content with scriptable content.

Then we can look at providing curation and auditing as part of the store process in combination with slowly improving sandbox support.

Do I need to do anything as a user?

If you install content from the store, I would advise checking it locally or looking for reviews from trusted sources.

If you're a sys-admin you might want to consider adding the following to block users installing addons with the following kiosk snippet.

/etc/xdg/kdeglobals

[KDE Action Restrictions][$i]
ghns=false

Splashscreen contributions 🔗

digiKam 00:00 +00:00

RSS

For the next digiKam releases, the digiKam team needs photographs for digiKam and Showfoto splash-screens. Proposing photo samples as splash-screens is a simple way for users to contribute to digiKam project. The pictures must be correctly exposed/composed, and the subject must be chosen from a real photographer’s inspiration. Note that we will add a horizontal frame to the bottom of the image as in the current splashes.

Monday, 18 March 2024

Setting up a Toggleable Side Panel in KDE Plasma 6 🔗

Nathan Upchurch

@nathanu:matrix.org 00:00 +00:00

Atom

Since a brief tryst with Ubuntu Budgie Edition, I’ve dearly missed its Raven side-panel, a special panel on the side of the screen that can be opened and closed with a click. As someone who needs a clean, minimal desktop, the workflow is just too perfect — when you have two or three widgets that you use frequently, but not frequently enough that they warrant permanent homes on a main panel, just stuff them into a disappearing side-panel that can be called with a quick key-combination or by clicking on an icon; It’s a great way to keep things out of the way, but within reach, without having a permanently cluttered system tray that you might want to keep clear for things like email notifications.

A cropped screenshot of my plasma desktop showing a side-panel on the right side of the screen containing the clipboard history widget and the media player widget. On the bottom panel is the Scriptinator plugin, showing a tooltip the following title "Show Panel," and body text "Show the hidden right panel. — My side panel, and the widget that launches it.

There are some drawbacks; this workflow isn’t well supported on KDE Plasma, so it’s a bit of a faff to set up, and only a few widgets will display nicely on a wide side-panel. For instance, it would be a dream to have the KDE weather widget automatically take advantage of the horizontal space and display the information that would usually be in its dropdown, but what you get instead is a giant icon, for now at least. I use my side-panel for my clipboard history and the media player widget, both of which play nicely with a side-panel. Another niggle I have with it is that, as far as I know, there’s no way to disable activation of the panel when your mouse pointer makes contact with the screen edge. This is a mild to moderate inconvenience when you’re working with applications that have toolbars on the sides of the window, like design applications often do.

For me, personally, the drawbacks aren’t so severe as to put me off of the workflow.

Creating and configuring the panel #

First, you’ll need to create a panel. To do this, right click on an empty section of your desktop, and select “Add Panel > Empty Panel.” When the panel appears, right click it and select “Enter Edit Mode.” Set up your panel however you like, but you will need to set “Visibility” to “Auto Hide” and may want to give it a width of at least 400px or so.

The panel settings configuration window.

Setting up the script #

Now, if you wanted to show and hide your panel with a keyboard shortcut, you can set up a focus shortcut in the panel settings window and stop here. If, like me, you want to toggle your panel by clicking on an icon somewhere, we’re going to have to use a wee script, but don’t worry, it’s not as hard as it sounds and I’ll take you through it step by step.

Before we can put our script together, we’re going to need to know what the ID of our panel is. Open up KRunner with Alt+F2 or Alt+Space and run plasma-interactiveconsole. This will launch KDE’s Desktop Shell Scripting Console. In the console, type print(panelIds); and click “Execute.” Assuming you entered that in correctly, what you should see now in the output console beneath the text editor is a series of numbers — the ID numbers of our panels. Keep a note of these numbers.

The interactive console showing a series of panel IDs printed to the console. — Look at those IDs.

Clear the text editor and enter the following:

let panel = panelById(401);

panel.hiding === "autohide" ? panel.hiding = "windowsgobelow" : panel.hiding = "autohide";

This will check if our panel is set to auto-hide; if it is, the script will set the panel to “windows go below” mode, otherwise it will set the panel to auto-hide.

Now to make use of those panel ID numbers. Which number corresponds to your new side-panel? While I can’t be sure, chances are it’s the last number on the list as we’ve just made the new panel a moment ago. So in the script above, where I have entered 401, enter the last number in your ID list and click “Execute.” At this point, if the ID number is correct, your panel should appear; click “Execute” once more to hide it.

Alright, we’ve got our script ready, so we just need one more thing in place: a button or icon that we can click on to show and hide the panel. Fortunately, we can use a widget called “Scriptinator” to provide just this. Right click on an empty area of your desktop or a panel, click “Add Widgets,” and “Get New Widgets.”

A cropped screenshot of the widgets panel with the "get new widgets" button at the top. — Let’s get that widget.

From here, find and install Scriptinator. Once installed, simply drag it where you’d like it to live, either on your desktop, or on a panel. Once you’ve done that, right click on the widget and choose “Configure Scriptinator.” Here, enter the path of the icon you’d like to use in “Custom icon full path;” I used /usr/share/icons/breeze-dark/actions/22/sidebar-expand-right-symbolic.svg. In “OnClick Script,” enter the following:

qdbus org.kde.plasmashell /PlasmaShell evaluateScript ''

and between those single-quote marks, paste in the full script we put together in the Desktop Shell Scripting Console, like this:

qdbus org.kde.plasmashell /PlasmaShell evaluateScript 'let panel = panelById(401);

panel.hiding === "autohide" ? panel.hiding = "windowsgobelow" : panel.hiding = "autohide";'

Set up a tooltip if you like, hit apply, and test out your toggle button.

Success! #

If you’ve done everything correctly, you should see your side-panel appear when you click the widget and disappear when you click a second time. You may need to restart to see your icon applied to the widget; if you don’t want to wait, you can drop the file path into “OnClick icon full path” in your Scriptinator configuration.

Sunday, 17 March 2024

Kile 2.9.95 / 3.0 beta 4 released 🔗

Gruenich 20:25 +00:00

Atom

We have a release of Kile 2.9.95, also known as 3.0 beta 4! Earlier today, Michel Ludwig tagged the current Git master. This is the first beta release since October 2019. Beside the port to KDE Frameworks 6 and Qt 6, it provides a couple of new features and bug fixes.

New features

Port to KDE Frameworks 6 & Qt 6 (Port by Carl Schwan)
Enable high-dpi support
Provide option to hide menu bar (Patch by Daniel Fichtner, #372295)
Configurable global default setting for the LivePreview engines (Patch by Florian Zumkeller-Quast, #450332)
Remove offline copy of "LaTeX2e: An unofficial reference manual", use online version instead (Patch by myself, Christoph Grüninger, Issue #7)

Fixed bugs

Kile crashes on selecting "Browse" or "Zoom" for document preview (Patch by Carl Schwan, #465547, #476207, #467435, #452618, #429452)
Kile crashes when generating new document (Patch by Carl Schwan, #436837)
Ensure \end{env} is inserted in the right place even when the user uses tabs for indentation (Patch by Kishore Gopalakrishnan, #322654)
Avoid saving console commands in bash history (Patch by Alessio Bonfiglio, #391537, #453935)
Don't crash when deleting templates (#413506)
Avoid crashing when closing a document that is being parsed (#404164)

Thanks to all the contributors. They fixed bugs, wrote documentation, modernized the code, and in general took care of Kile.

Enjoy the latest Kile release!

digiKam 8.3.0 is released 🔗

digiKam 00:00 +00:00

RSS

digiKam 8.3.0 AppImage Bundle Running Under Kubuntu Dear digiKam fans and users,

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

This version arrives with the internal RAW decoder Libraw updated to the rolling-release snapshot 2024-02-02. 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.

一次简单的分享 🔗

Lv Haonan

GSoC 00:00 +00:00

Atom

利用条件表达式完成下面的命题:学习成绩成绩>=90分的同学用A表示，学习成绩在60～89分的同学用B表示哦=，学习成绩在60分以下的同学用C表示.
int gra=0;

class

class 是一种用于创建用户定义的数据类型的关键字。它是面向对象编程（OOP）的基本概念之一。通过使用 class，您可以将数据成员（属性）和成员函数（方法）封装在一个单一的实体中，从而使代码更有组织性和可维护性。

语法： class 类名 {访问权限 : 属性\行为}；

class 的功能与struct类似，但提供了更为丰富的功能.

class 可以在设计的时，可以把属性和行为放在不同的权限下，加以控制.

权限的分类：

public 公共权限
protected 保护权限
private 私有权限

//公共权限  public
//保护权限  protected
//私有权限  private
//私有权限与保护权限在类内可以访问，在类外不可以访问
class Num
{
public:
    int m_A;
protected:
    int m_B;
private:
    int m_C;
public:
    void func()
    {
m_A=10;
        m_B=20;
        m_C=30;
    }
}

int main()
{
Num m;
    m.m_A=10;
    //m.m_B=20;//类外不可以访问
    //m.m_C=30;
}

class与struct的区别：

struct 默认权限为公共
class 默认权限为私有

对象的初始化清理

对象的初始化和清理是两个非常重要的安全问题.

一个对象或者变量没有初始状态，对其使用后果未知

同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题

c++利用了构造函数和析构函数解决上述问题，这两个函数将会被编译器自动调用，完成对象初始化和清理工作。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果我们不提供构造和析构，编译器会给我们提供空实现

构造函数

构造函数语法： 类名(){}

构造函数，没有返回值也不写void
函数名称与类名相同
构造函数可以有参数，因此可以发生重载
程序在调用对象时候会自动调用构造，无需手动调用，而且只会调用一次

class Num
{
public:
    Num(int a): m_A(a)
    {
cout << "gz" << endl;
    }
    int m_A;
};

构造函数的分类：

按参数
- 有参构造
- 无参构造
按类型
- 普通构造
- 拷贝构造

构造函数的调用方法：

括号法

1
2
3

Person P;//默认构造时后面不要加括号
Person p1(10);
Person p2(p1);

显示法

1
2
3

Person p;
Person p1=Person(10);
Person P2=Person(p2);

隐式转换法

1 2	Person p4=10; Person p5=p4;//相当于Person p5=Person(10);

explcit

在 C++ 中， explicit 关键字用于防止编译器进行隐式类型转换。当您将构造函数或转换函数声明为 explicit 时，这意味着该构造函数或转换函数只能由程序员显式调用，而不能由编译器隐式调用。

class P
{
public:
    P()
    {

    }
    P(int a)
    {
        m_A = a;
    }
    explicit P(P& a)
    {
        m_A = a.m_A;
    }
    int m_A;
};

int main()
{
    P p;
    p.m_A = 1;
    //P p1 = p;//会报错，因为声明不可以隐式类型转换
    P p1=P(1);
    cout << p1.m_A << endl;
    return 0;
}

拷贝构造函数调用时机

c++拷贝构造函数调用时机

使用一个创建完毕的对象来初始化一个新对象
值传递的方式给函数参数传值(做参数)
以值的方式返回局部对象(做返回值)

构造函数调用规则：

默认情况下，c++编译器至少给一个类添加3个函数

1.默认构造参数（无参，函数体为空）

2.默认析构函数（无参，函数体为空）

3.默认拷贝构造函数，对属性值进行拷贝

规则如下：

如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造
如果用户定义拷贝构造函数，c++不会在提供其他的构造函数

深浅拷贝

浅拷贝：简单的赋值操作

深拷贝：在堆区重新申请空间，进行拷贝操作.

class Num
{
public:
    Num()
    {
        cout << "gz" << endl;
    }
    Num(const Num &other)
    {
        m_A=other.m_A;
        m_B=new int (*other.m_B);
        cout << "kb" << endl;
    }
    ~Num()
    {
        if(this->m_B)
        {
            delete this->m_B;
            this->m_B=nullptr;
        }
    }
    int m_A;
    int *m_B;
};

int main()
{
    Num a;
    a.m_A=1;
    a.m_B=new int(20);
    Num b(a);
    cout << b.m_A << endl;
    cout << *b.m_B << endl;
    cout << a.m_B << endl;
    return 0;
}

class 与 struct

C++中的 struct 和 class 基本是通用的，唯有几个细节不同：

使用 class 时，类中的成员默认都是 private 属性的；而使用 struct 时，结构体中的成员默认都是 public 属性的。
class 继承默认是 private 继承，而 struct 继承默认是 public 继承。
class 可以使用模板，而 struct 不能。

引用

作用：给变量起别名

语法：数据类型 &别名 =原名

注意事项

引用必须要初始化
引用一旦初始化后，就不可以更改

引用可以简化指针的用法.

引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

通过引用参数产生的效果按地址传递是一样的。引用的语法更加的简单。

引用是可以作为函数的返回值存在的.

不返回局部变量的引用.

函数的调用可以作为左值.

int sum1 = 0;
int& sum(int &a,int &b) 
{
    sum1 = a + b;
    return sum1;
}

int main()
{
    int a=10;
    int b=10;
    sum(a,b)=30;
    cout << sum1 << endl;    
    return 0;
}

本质：引用的本质在c++内部实现是一个指针常量.

void func(int &ref)
{
    ref=100;
}

int main()
{
int a=10;
    //自动转换为int *const ref = &a;指针常量是指针指向不可改，也说明为什么引用不可以改
    int &ref=a;
    ref=20;
    
    func(a);
    return 0;
}

左值 & 右值

C++中所有的值都必然属于左值、右值二者之一.

左值是指表达式结束之后依然存在的持久化对象

右值是之表达式结束时就不再存在的临时对象.

所有的具有变量或者对象都是左值，而右值不具有名称.很难得到左值和右值的真正定义，但是有一个可以区分的便捷方法：看能否对表达式取地址，如果可以，则为左值，否则为右值。

右值又分为 将亡值和纯右值。

纯右值是C++98标准中右值的概念，如非引用返回的函数返回的临时变量值;

而将亡值则是c++新增的和右值引用相关的表达式，这样的表达式通常是将要移动的对象。&&函数返回值、std::move()函数的返回值等.

categories来说，c++11前，只有左值(lvalue)和右值(rvalue)；c++11后，任何value categories(值类型)都是下面的三种之一：lvalue， xvalue， prvalue。gvalue为广义左值，包括lvalue和xvalue，rvalue为右值，包括xvalue和prvalue，可见xvalue可以是左值也可以是右值。

纯右值(prvalue)：纯右值是传统右值的一部分，纯右值是表达式产生的中间值，不能取地址。纯右值一定会在表达式结束后被销毁。

一般有以下的条件：

本身就是纯粹的字面值，如3、false.
求值结果相当于字面值或是一个不具名的临时变量.

消亡值(xvalue)是c++11的不具名的右值引用引入的。以下情况的表达式求值结果为xvalue，准确的说叫不具名右值引用，这种属于新的”右值”，由右值引用带来，通常用来完成移动构造或移动赋值的特殊任务。事实上，将亡值不过是C++11提出的一块晦涩的语法糖。它与纯右值在功能上及其相似，如都不能做操作符的左操作数，都可以使用移动构造函数和移动赋值运算符。当一个纯右值来完成移动构造或移动赋值任务时，其实它也具有“将亡”的特点。一般，我们不必刻意区分一个右值到底是纯右值还是将亡值。

左值引用 & 右值引用

c++98中的引用很常见了，就是给变量取了个别名，在c++11中，因为增加了右值引用(rvalue reference)的概念，所以c++98中的引用都称为了左值引用(lvalue reference**)**。 c++11中的右值引用使用的符号是&&

class A{
public:
int a;    
};

A getTemp()
{
    return A();
}

int main()
{
    int a=10;
    int &refA = a;//左值引用
    //int &ref2 = 2; //编译错误
    int &&ref1=1;//右值引用
    int b =5;
    //int && refB =b;//编译错误，不能将一个左值赋值给一个右值引用
    A&& refIns = getTemp();//函数返回值是 右值
    return 0;
}

getTemp()返回的右值本来在表达式语句结束后，其生命也就该终结了（因为是临时变量），而通过右值引用，该右值又重获新生，其生命期将与右值引用类型变量refIns的生命期一样，只要refIns还活着，该右值临时变量将会一直存活下去。实际上就是给那个临时变量取了个名字。

注意：这里refIns的类型是右值引用类型(int &&)，但是如果从左值和右值的角度区分它，它实际上是个左值。因为可以对它取地址，而且它还有名字，是一个已经命名的右值。

常量左值引用

左值引用只能绑定左值，右值引用只能绑定右值，如果绑定的不对，编译就会失败。但是，常量左值引用却是个奇葩，它可以算是一个“万能”的引用类型，它可以绑定非常量左值、常量左值、右值，而且在绑定右值的时候，常量左值引用还可以像右值引用一样将右值的生命期延长，缺点是，只能读不能改。

1	const A &a =getTmp();//不会报错

int max(const int &a,const int &b)
{
    return a+b;
}

int main()
{
    int a=1;
    int b=2;
    cout << max(1,2) << endl;
    return 0;
}

总结

T是一个数据类型

左值引用，使用T&只能绑定左值
右值引用，使用T&&只能绑定右值
常量左值，使用const T&，既可以绑定左值也可以绑定右值
已命名的右值引用，编译器会认为是个左值
编译器有返回值优化，但不要过于依赖(-fno-elide-constructors)

移动语义

移动构造函数 & 移动赋值函数

用c++实现一个字符串类MiniString，MiniString内部管理一个C语言的char *数组，这个时候一般都需要实现拷贝构造函数和拷贝赋值函数，因为默认的拷贝是浅拷贝，而指针这种资源不能共享。代码如下：

class MiniString
{
public:
    static size_t kbsize;
    MiniString(const char *str)
    {
        if(str)
        {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        }
        else
        {
            m_data = new char[1];
            *m_data = '\0';
        }
    }
    MiniString(const MiniString &other)
    {
        kbsize ++;
        m_data=new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        //cout << "kb" << kbsize << endl;
    }   
    MiniString &operator=(const MiniString &other)
    {
        if(this==&other)
        {
            return *this;
        }
        delete[] m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    ~MiniString()
    {
        if(m_data)
        {
            delete[] m_data;
        }
    }
private:
    char *m_data;
};

size_t MiniString::kbsize =0;

int main()
{
    vector<MiniString> v;
    v.reserve(1000);
    for(int i=0; i<1000; i++)
    {
        v.push_back(MiniString("hello world!"));
    }
    cout << MiniString::kbsize << endl;

    return 0;
}

代码执行了1000次拷贝构造函数，如果MiniString("hello")构造出来的字符串本来就很长，构造一遍就很耗时了，最后却还要拷贝一遍，而MiniString("hello")只是临时对象，拷贝完就没什么用了，这就造成了没有意义的资源申请和释放操作，如果能够直接使用临时对象已经申请的资源，既能节省资源，又能节省资源申请和释放的时间。而C++11新增加的移动语义就能够做到这一点。

移动语义避免了移动原始数据，而只是修改了记录。要实现移动语义就必须增加两个函数：移动构造函数和移动赋值构造函数。必须让编译器知道什么时候需要复制，什么时候不需要复制。这就是右值引用发挥最大作用的地方。

#include <iostream>
using namespace std;
#include <cstring>
#include <vector>

class MiniString
{
public:
    static size_t kbsize;
    static size_t movesize;
    static size_t Fkbsize;
    static size_t Fmovesize;
    MiniString(const char *str)
    {
        if(str)
        {
            m_data = new char[strlen(str) + 1];
            strcpy(m_data, str);
        }
        else
        {
            m_data = new char[1];
            *m_data = '\0';
        }
    }
    MiniString(const MiniString &other)
    {
        kbsize ++;
        m_data=new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        // cout << "kb" << kbsize << endl;
    } 
    MiniString(MiniString &&other)
    {
        m_data=other.m_data;
        movesize ++;
        other.m_data=NULL;
    }
    MiniString &operator=(const MiniString &other)
    {
        Fkbsize ++;
        if(this==&other)
        {
            return *this;
        }
        delete[] m_data;
        m_data = new char[strlen(other.m_data) + 1];
        strcpy(m_data, other.m_data);
        return *this;
    }
    MiniString &operator=(MiniString && other)
    {
        Fmovesize++;
        if(this==&other)
        {
            return *this;
        }
        delete[] m_data;
        m_data=other.m_data;
        other.m_data=NULL;
        return *this;
    }
    ~MiniString()
    {
        delete[] m_data;
    }
private:
    char *m_data;
};

size_t MiniString::kbsize =0;
size_t MiniString::movesize=0;
size_t MiniString::Fkbsize=0;
size_t MiniString::Fmovesize;

int main()
{
    vector<MiniString> v;
    v.reserve(1000);
    for(int i=0; i<1000; i++)
    {
        v.push_back(MiniString("hello world!"));
    }
    cout <<"kbsize\t"<< MiniString::kbsize << endl;
    cout <<"Fkbsize\t"<< MiniString::Fkbsize << endl;
    cout <<"movesize\t"<< MiniString::movesize << endl;
    cout <<"Fmovesize\t"<< MiniString::Fmovesize << endl;

    return 0;
}

移动构造函数与拷贝构造函数的区别是，拷贝构造的参数是const MiniString& str，是常量左值引用，而移动构造的参数是MiniString&& str，是右值引用，而MiniString("hello")是个临时对象，是个右值，优先进入移动构造函数而不是拷贝构造函数。而移动构造函数与拷贝构造不同，它并不是重新分配一块新的空间，将要拷贝的对象复制过来，而是”偷”了过来，将自己的指针指向别人的资源，然后将别人的指针修改为nullptr，这一步很重要，如果不将别人的指针修改为空，那么临时对象析构的时候就会释放掉这个资源，”偷”也白偷了。

不用奇怪为什么可以抢别人的资源，临时对象的资源不好好利用也是浪费，因为生命周期本来就是很短，在你执行完这个表达式之后，它就毁灭了，充分利用资源，才能很高效。

当类中同时包含拷贝构造函数和移动构造函数时，如果使用临时对象初始化当前类的对象，编译器会优先调用移动构造函数来完成此操作。只有当类中没有合适的移动构造函数时，编译器才会退而求其次，调用拷贝构造函数。

std::move()

对于一个左值，肯定是调用拷贝构造函数了，但是有些左值是局部变量，生命周期也很短，能不能也移动而不是拷贝呢？C++11为了解决这个问题，提供了std::move()方法来将左值转换为右值，从而方便应用移动语义。其实就是告诉编译器，虽然我是一个左值，但是不要对我用拷贝构造函数，而是用移动构造函数。std::move 的源码实现：

// FUNCTION TEMPLATE move
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
    return static_cast<remove_reference_t<_Ty>&& >(_Arg);
}
//_NODISCARD 这是一种标记，用于指示编译器在忽略函数返回值时发出警告。
//constexpr:表示这个函数是在编译时计算的
//noexcept:表示这个函数不会抛出异常
//remove_reference_t 是 C++ 标准库 <type_traits> 中的一个模板元函数，用于移除类型的引用修饰符（& 或 &&）。

static_cast:

用于显示类型转换.在编译时进行类型检查，用于在不同但相关的类型之间检查.

其他类型转换的函数

dynamic_cast:
- 用于在运行时进行安全的向下转型，主要用于处理继承关系中的多态类型
- 仅在具有虚函数的类层次结构中才有效
- 如果转型合法，则返回目标类型的指针或引用，否则返回nullptr
reinterpret_case：
- 执行底层的二进制位级别的转换
- 非常强大，但潜在的不安全，因为它可以忽略类型之间的语义差异

可以看到 std::move 是一个模板函数，通过remove_reference_t获得模板参数的原本类型，然后把值转换为该类型的右值。用C++大师 Scott Meyers 的在《Effective Modern C++》中的话说， std::move 是个cast ，not a move.

注意：使用 move 意味着，把一个左值转换为右值，原先的值不应该继续再使用（承诺即将废弃）。

MiniString str1("hello"); // 调用构造函数
MiniString str2("world"); // 调用构造函数
MiniString str3(str1);    // 调用拷贝构造函数
MiniString str4(std::move(str1));    // 调用移动构造函数
// cout << str1.get_c_str() << endl; // 此时str1的内部指针已经失效了！不要再使用
// 虽然str1中的m_dat已经称为了空，但是str1这个对象还活着，知道出了它的作用域才会析构，
// 而不是move完了立刻析构
MiniString str5;
str5 = str2;            // 调用拷贝赋值函数
MiniString str6;
str6 = std::move(str2); // 调用移动赋值函数，str2的内容也失效了，不要再使用

要注意一下几点：

str6 = std::move(str2)，虽然将str2的资源给了str6，但是str2并没有立刻析构，只有在str2离开了自己的作用域的时候才会析构，所以，如果继续使用str2的m_data变量，可能会发生意想不到的错误。
如果我们没有提供移动构造函数，只提供了拷贝构造函数，std::move()会失效但是不会发生错误，因为编译器找不到移动构造函数就去寻找拷贝构造函数，也这是拷贝构造函数的参数是const T&常量左值引用的原因！
c++11中的所有容器都实现了move语义，move只是转移了资源的控制权，本质上是将左值强制转化为右值使用，以用于移动拷贝或赋值，避免对含有资源的对象发生无谓的拷贝。move对于拥有如内存、文件句柄等资源的成员的对象有效，如果是一些基本类型，如int和char[10]数组等，如果使用move，仍会发生拷贝（因为没有对应的移动构造函数），所以说move对含有资源的对象说更有意义。

通用引用

当右值引用和模板结合的时候，就复杂了。T&&并不一定表示右值引用，它可能是个左值引用又可能是个右值引用。例如：

template <class T>
void func(T&&a,T&&b)
{
    cout << a+b << endl;
}

int main()
{
    int a=10;
    int b=20;
    func(a,b);
    func(200,300);
    return 0;
}

如果上面的函数模板表示的是右值引用的话，肯定是不能传递左值的，但是事实却是可以。这里的&&是一个未定义的引用类型，称为universal references，它必须被初始化，它是左值引用还是右值引用却决于它的初始化，如果它被一个左值初始化，它就是一个左值引用；如果被一个右值初始化，它就是一个右值引用。

注意：只有当发生自动类型推断时（如函数模板的类型自动推导，或auto关键字），&&才是一个universal references

1 2	template <typename T> void func(T&&a);//这里T需要推导，所以&&是universal references

template <class T>
class Person
{
public:
    Person(T age)
    {
        m_age = age;
    }
    T m_age;
};

int main()
{
    Person<int> p(1);
    cout <<p.m_age << endl;
    return 0;
}

template<typename T>
class Test {
  Test( Test&& rhs );   // Test是一个特定的类型，不需要类型推导，所以&&表示 右值引用  
};

1 2	template <typename T> void func(std::vector<T>&& data);//在往vector添加元素的时候已经将T推断出来，所以是右值引用

所以最终还是要看T被推导成什么类型，如果T被推导成了string，那么T&&就是string&&，是个右值引用，如果T被推导为string&，就会发生类似string& &&的情况，对于这种情况，c++11增加了引用折叠的规则，总结如下：

所有的右值引用叠加到右值引用上仍然使一个右值引用。
所有的其他引用类型之间的叠加都将变成左值引用。

完美转发

所谓转发，就是通过一个函数将参数继续转交给另一个函数进行处理，原参数可能是右值，可能是左值，如果还能继续保持参数的原有特征，那么它就是完美的。

#include <iostream>
using namespace std;

void process(int &i)
{
    cout << "process(int &)" << i << endl;
}

void process(int &&i)
{
    cout << "process(int &&)" << i << endl;
}

void myforward(int &&i)
{
    cout <<"myforward(int &&)" << i << endl;
    //process(i);
    process(forward<int>(i));
}

int main()
{
    int a =0;
    process(a);
    process(1);
    process(move(a));
    myforward(1);
    myforward(move(a));
    return 0;
}

上面的例子就是不完美转发，而c++中提供了一个std::forward()模板函数解决这个问题。将上面的myforward()函数简单改写一下：

上面修改过后还是不完美转发，myforward()函数能够将右值转发过去，但是并不能够转发左值，解决办法就是借助universal references通用引用类型和std::forward()模板函数共同实现完美转发。例子如下：

void RunCode(int &&m) {
    cout << "rvalue ref" << endl;
}
void RunCode(int &m) {
    cout << "lvalue ref" << endl;
}
void RunCode(const int &&m) {
    cout << "const rvalue ref" << endl;
}
void RunCode(const int &m) {
    cout << "const lvalue ref" << endl;
}

// 这里利用了universal references，如果写T&，就不支持传入右值，而写T&&，既能支持左值，又能支持右值
template<typename T>
void perfectForward(T && t) {
    RunCode(forward<T> (t));
}

template<typename T>
void notPerfectForward(T && t) {
    RunCode(t);
}

int main()
{
    int a = 0;
    int b = 0;
    const int c = 0;
    const int d = 0;

    notPerfectForward(a);       // lvalue ref
    notPerfectForward(move(b)); // lvalue ref
    notPerfectForward(c);       // const lvalue ref
    notPerfectForward(move(d)); // const lvalue ref

    cout << endl;
    perfectForward(a);       // lvalue ref
    perfectForward(move(b)); // rvalue ref
    perfectForward(c);       // const lvalue ref
    perfectForward(move(d)); // const rvalue ref
}

原文链接

Saturday, 16 March 2024

This weekend I am contributing to Transitous. You should too. 🔗

Paul Brown 11:41 +00:00

RSS

Transitous is a new community-driven routing service. Add your own city and help make it great.

Friday, 29 March 2024

shell

主函数

屏蔽信号

tcgetattr

tcsetattr

print

mycd

parse

pipe

dup2

executeCommand

代码

shepp.hpp

func.cpp

shell.cpp

Wednesday, 27 March 2024

Saturday, 23 March 2024

Wednesday, 20 March 2024

Recent events

Expectations

What can we do better?

Do I need to do anything as a user?

Monday, 18 March 2024

Creating and configuring the panel #

Setting up the script #

Setting up the Scriptinator widget #

Success! #

Sunday, 17 March 2024

New features

Fixed bugs

利用条件表达式完成下面的命题:学习成绩成绩>=90分的同学用A表示，学习成绩在60～89分的同学用B表示哦=，学习成绩在60分以下的同学用C表示.

class

对象的初始化清理

构造函数

拷贝构造函数调用时机

深浅拷贝

class 与 struct

引用

注意事项

左值 & 右值

左值引用 & 右值引用

常量左值引用

总结

移动语义

移动构造函数 & 移动赋值函数

std::move()

通用引用

完美转发

Saturday, 16 March 2024