Harry's questions

-我想使用空格作为分隔符来拆分包含第一个字符的字符串。但以下代码似乎不起作用。如果我删除该-字符，它就会正确拆分。这是脚本

#!/bin/bash

string="-e -/a/b/c/d"
arr=($string)
arrLen=${#arr[@]}
echo $arrLen
echo ${arr[0]} #prints empty
if [ $arrLen = 2 ] && [ ${arr[0]} = "-e" ]; then #this condition gets passed surprisingly
    echo "Hi ${arr[1]}"
fi

输出

2

Hi -a/b/c/d

如何使用cat带有此处文档的 shell 脚本命令来创建文件”

#!/bin/bash

create_file () {
    cat > a.txt << EOF
    0 abc def 
    ghi jkl mno
    pqrs tuv wxyz
    EOF
}

create_file

错误

Syntax error: end of file unexpected (expecting "}")

是否可以将数组第一个元素的地址作为参数传递给std::bit_cast.

#include <bit>
#include <iostream>

struct A {
    int a;
    int b;
    int c;
    int d;
    int e;

    void print() {
        std::cout << a << ", " << b << ", " << c << ", " << d << ", " << e << std::endl;
    }
};

int main() {
    char arr[20]{};
    // arr is filled with some data
    A a = std::bit_cast<A>(arr);
    a.print();

    const char* arrp = arr;
    // doesn't compile
    A b = std::bit_cast<A>(arrp);
    b.print();
}

错误

<source>: In function 'int main()':
<source>:23:27: error: no matching function for call to 'bit_cast<A>(const char*&)'
   23 |     A b = std::bit_cast<A>(arrp);
      |           ~~~~~~~~~~~~~~~~^~~~~~
In file included from <source>:1:
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5: note: candidate: 'template<class _To, class _From> constexpr _To std::bit_cast(const _From&) requires  sizeof (_To) == sizeof (_From) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From)'
   81 |     bit_cast(const _From& __from) noexcept
      |     ^~~~~~~~
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5: note:   template argument deduction/substitution failed:
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5: note: constraints not satisfied
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit: In substitution of 'template<class _To, class _From> constexpr _To std::bit_cast(const _From&) requires  sizeof (_To) == sizeof (_From) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From) [with _To = A; _From = const char*]':
<source>:23:27:   required from here
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:81:5:   required by the constraints of 'template<class _To, class _From> constexpr _To std::bit_cast(const _From&) requires  sizeof (_To) == sizeof (_From) && __is_trivially_copyable(_To) && __is_trivially_copyable(_From)'
/opt/compiler-explorer/gcc-13.2.0/include/c++/13.2.0/bit:83:27: note: the expression 'sizeof (_To) == sizeof (_From) [with _To = A; _From = const char*]' evaluated to 'false'
   83 |     requires (sizeof(_To) == sizeof(_From))
      |              ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
Compiler returned: 1

我正在通过网络套接字以大端格式从另一台主机接收数据。如何解释以本机字节序格式接收的字节（例如获取视图或重新解释这些字节）而不复制到临时变量中。

#include <iostream>
#include <cstdint>

struct A {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct A
    }
};

struct B {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct B
    }
};

struct C {
    uint16_t msg_id;
    // contains many other fields where total size is greater than 4096

    void print() const {
        // print all the fields of struct C
    }
};

int main() {
    char buff[8192];
    while (true) {
        // data is received in network byte order (big endian) but my system is little endian
        const auto recvd_len = recvfrom(sock_fd, buff, sizeof(buff), 0, nullptr, nullptr);
        const uint16_t msg_id = (buff[0] << 8) | (buff[1] & 0xFF);

        switch (msg_id) {
            case 0x0001: {
                // reinterpret the bytes received as struct A, copy elision
                const A* a_obj = reinterpret_cast<const A*>(buff);
                a_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            case 0x0002: {
                // reinterpret the bytes received as struct B, copy elision
                const B* b_obj = reinterpret_cast<const B*>(buff);
                b_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            case 0x0003: {
                // reinterpret the bytes received as struct C, copy elision
                const C* c_obj = reinterpret_cast<const C*>(buff);
                c_obj->print();
                // the above print call works correctly only if my system is big endian but not little endian
            }

            break;

            default:
            break;
        }
    }
}

如何operator()(Generator& g, const param_type& params);使用std::uniform_int_distribution. 这是我的代码

#include <iostream>
#include <random>

int get_random_int(const int lower_limit, const int upper_limit) {
   std::random_device rd{};
   std::mt19937 gen{rd()};

   static std::uniform_int_distribution<> dist;
   
   // use operator()(Generator& g, const param_type& params);
   return dist(gen, lower_limit, upper_limit);
}

int main() {
    std::cout << get_random_int(1, 1000000) << std::endl;
}

我想知道是否可以对从crate https://docs.rs/bincode/2.0.0-rc.3/bincode/fn.decode_from_slice.html函数返回的类型使用if let Ok()语法，这需要显式类型注释Result<Tuple(Struct, usize), DecodeError>bincode::decode_from_slicebincode

我尝试了以下语法

struct A {
    a: i32,
    b: i32,
}

let mut recv_buff = [0u8; 1024];

if let Ok((a_obj, _): (A, usize)) = bincode::decode_from_slice(recv_buff, bincode::config::standard().with_big_endian()) {
        
}

错误

if let Ok((a_obj, _): (A, usize)) = bincode::decode_from_slice(recv_buff, bincode::config::standard()....
    |                                         ^ expected one of `)`, `,`, or `|`