小编0x5*_*453的帖子

在以下示例中：

struct Foo {
    [[maybe_unused]] int member = 1;
    void bar() {
        [[maybe_unused]] int local = 0;
    }
};

int main(int argc, char* argv[]) {
    Foo f{};
    f.bar();
    return 0;
}

GCC 发出警告，其中 Clang 和 MSVC 没有：

warning: 'maybe_unused' attribute ignored [-Wattributes]
     [[maybe_unused]] int member = 1;

据我所知，这应该是合法的（并且不会被编译器忽略）。根据标准：

10.6.7 可能未使用的属性 [dcl.attr.unused]
...
2. 该属性可以应用于类的声明、typedef-name、变量、非静态数据成员、函数、枚举，或枚举器。
...

我讨厌在“编译器错误”锤子上摇摆不定，但我不确定在这种情况下还有什么可能。

有没有人有任何见解？

我最近开始在我的代码中使用类型提示，到目前为止发现它们（大部分）非常有用。

但是，我真正不喜欢的一件事是强制类型检查器假定变量属于某种类型的语法。鉴于这个例子：

import itertools
from typing import Iterable, Tuple
x: Iterable[Tuple[str, str]] = itertools.combinations('abc', 2)
# error: Incompatible types in assignment (expression has type "Iterable[Tuple[str, ...]]", variable has type "List[Tuple[str, str]]")

据我所知，解决此问题的推荐方法是明确cast对象以强制类型检查器使用指定的类型，例如：

import itertools
from typing import Iterable, Tuple, cast
x = cast(Iterable[Tuple[str, str]], itertools.combinations('abc', 2))

我个人觉得这个解决方案有点恶心。我主要担心的是，对于没有经验的读者来说，不清楚cast是否纯粹是为了帮助静态分析器。（如果我还不知道，我会根据名称和上下文假设它正在转换并复制到指定类型的对象，而实际上没有运行时成本。）

cast看起来像任何旧的函数调用。当我看到对某个值调用了一个函数时，我希望该值发生变异和/或发生其他一些副作用，但在这种情况下，唯一的副作用是mypy停止抱怨。类型提示本身具有独特的语法，但我觉得这使新类型语法和传统 Python 语法的混合使线条变得模糊。（它已经有点模糊，因为您必须import使用类型并可以组合它们，但这是另一个讨论。）

是否有cast类似行为的替代语法？我还没有找到任何东西，但我希望有类似的东西：

x1 = itertools.combinations('abc', 2)) # cast: Iterable[Tuple[str, str]] 

x2: Iterable[Tuple[str, str]] = itertools.combinations('abc', 2)) # type: …

我正在重写旧的 CMake 设置以使用自动依赖传播等现代功能。（即使用类似的东西target_include_directories(<target> PUBLIC <dir>)代替include_directories(<dir>)。）目前，我们通过设置一堆全局目录属性来手动处理所有项目依赖信息。

在我的测试中，我发现了一些示例，其中新构建中的目标将链接到旧构建不会链接到的库。我没有明确链接到它，所以我知道这是来自目标的依赖项，但为了找到哪个（s）我必须递归查看项目的所有CMakeLists.txts，跟踪依赖关系层次直到我找到一个拉入有问题的图书馆。我们有几十个库，所以这不是一个简单的过程。

CMake 是否提供任何方法来查看每个目标明确添加了哪些依赖项，以及通过传递依赖项传播了哪些依赖项？

看起来--graphviz输出确实显示了这种区别，所以很明显 CMake 在内部知道上下文。但是，我想编写一个类似tree脚本来在命令行上显示依赖项信息，解析 Graphviz 文件听起来既像是一场噩梦，也是一场黑客攻击。

据我所知，cmake-file-api并没有包含此信息。我认为该codemodel/target/dependencies领域可能有用，但它列出了混合在一起的本地和传递依赖项。并且backtrace每个依赖项的字段仅与当前目标的add_executable/add_library调用相关联。

是否可以将属性应用于析构函数？ 示例：

#if defined (__GNUC__) && !defined(__clang__)
#  define TEST_PRE_ATTR [[deprecated]] __attribute__((deprecated))
#  define TEST_POST_ATTR __attribute__((error("test")))
#elif defined(_MSC_VER) && !defined(__clang__)
#  define TEST_PRE_ATTR [[deprecated]] __declspec(deprecated)
#  define TEST_POST_ATTR
#elif defined (__clang__)
#  define TEST_PRE_ATTR [[deprecated]] __attribute__((deprecated))
#  define TEST_POST_ATTR __attribute__((diagnose_if(true, "test", "error")))
#endif

struct Foo {
    //TEST_PRE_ATTR 
    void bar() 
    //TEST_POST_ATTR 
    {}

    TEST_PRE_ATTR
    ~Foo()
    TEST_POST_ATTR
    = default;
};

int main() {
    Foo* f = new Foo();
    f->bar();
    delete f;
    return 0;
}

GCC、Clang 和 MSVC 会忽略Foo::~Foo. 如果将相同的属性应用于Foo::bar …

我在使用unittest.TestCase.assertItemsEqual（或assertCountEqual在 Python 3 中）时遇到了一个让我有点困惑的问题，我无法在这里找到解决方案，所以我在这里发布我的修复程序以供后人使用：

以下单元测试在 Python 2 和 3 下均失败：

import six
import unittest

class Foo(object):
    def __init__(self, a=1, b=2):
        self.a = a
        self.b = b
    def __repr__(self):
        return '({},{})'.format(self.a, self.b)
    def __eq__(self, other):
        return self.a == other.a and self.b == other.b
    def __lt__(self, other):
        return (self.a, self.b) < (other.a, other.b)
    __hash__ = None

class Test(unittest.TestCase):
    def test_foo_eq(self):
        self.assertEqual(sorted([Foo()]), sorted([Foo()]))
        six.assertCountEqual(self, [Foo()], [Foo()])
        six.assertCountEqual(self, [Foo(1,2), Foo(2,3)], [Foo(2,3), Foo(1,2)])

unittest.main()

错误消息如下所示：

======================================================================
ERROR: test_foo_eq (__main__.Test)
----------------------------------------------------------------------
Traceback …

我正在尝试将文件从客户端发送到带有Java套接字的服务器.当我在同一台机器上测试时它工作正常,但是当我在不同的机器上测试时,我丢失了大量数据,导致文件损坏.如果我尝试发送一个非常小的文件(<20字节),它甚至不会到达服务器的while循环中的println.

这是我的代码:

Server.java

package edu.mst.cs.sensorreceiver;

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    private static final int PORT = 51111;
    private static final int CHUNK_SIZE = 1024;
    private static final File _downloadDir = new File("downloads/");

    public static void main(String[] args) {
        if (!_downloadDir.exists()) {
            if (!_downloadDir.mkdirs()) {
                System.err.println("Error: Could not create download directory");
            }
        }

        Socket socket = null;
        try {
            ServerSocket server = new ServerSocket(PORT);

            while (true) {
                System.out.println("Waiting for connection...");
                socket = server.accept();

                BufferedReader in = …

我有一个txt数据。它看起来如下

time pos
0.02 1
0.1 2
 ...

等等。所以每一行都用空格隔开。我需要将其转换为 CSV 文件。喜欢

time,pos
0.02,1
0.1,2
0.15,3

我怎样才能用 python 做到这一点？这是我尝试过的

time = []
pos = []

def get_data(filename):
    with open(filename, 'r') as csvfile:
        csvFileReader = csv.reader(csvfile)
        next(csvFileReader)
        for row in csvFileReader:
            time.append((row[0].split(' ')[0]))
            pos.append((row[1]))
    return

我有一个代表对角矩阵的类.我只沿着对角线存储元素,所以我不会浪费一堆0的空间.但是,我仍然希望能够使用双括号来访问数组中的元素.为了解决这个问题,我使用了一个内部类,如下所示:

template <class T>
class DiagonalMatrix
{
private:
  const T ZERO = 0;

  int _size;
  Vector<T> _data;

  class row
  {
  private:
    DiagonalMatrix<T>* _parent;
    int _row;
  public:
    row(DiagonalMatrix<T>* parent, const int row)
      : _parent(parent), _row(row) {}
    T& operator[](const int i);
  };

  class const_row
  {
  private:
    const DiagonalMatrix<T>* const _parent;
    int _row;
  public:
    const_row(const DiagonalMatrix<T>* const parent, const int row)
      : _parent(parent), _row(row) {}
    const T& operator[](const int i) const;
  };
  friend class row;
  friend class const_row;

public:
  row             operator[] (const int …

如果这个问题没有意义或者看起来很简单，但我想了解这些头文件是如何工作的，请原谅我

是否可以在头文件内部声明 int 等类型的变量？

我有以下代码，我声明窗口和窗口尺寸的行有问题。编译器说它们有多个定义，首先在主文件中定义，我只是在主文件中定义了#include“core.h”。 h”并在 core.cpp 中再次定义，其中我再次有一个#include“core.h”。

    #ifndef SFMLAPP_CORE_H
    #define SFMLAPP_CORE_H
    #include "SFML/Graphics.hpp"
    #include <iostream>
    
    sf::RenderWindow* window;///Window 
    float ScreenW,ScreenH;///Dimensions of the window
    
    struct position ///used in position handiling
     {
     float x=-1;
     float y=-1;
     };
    void printText(position pos,std::string Text,float size,float outlineSize);


    #endif //SFMLAPP_CORE_H

int uniquePaths(int m, int n) {
    int num = m+n-2;
    int den=1;
    double ans = 1;
    while(den<=m-1) {
        ans = ans*(num--)/(den++);
    }
    cout<<ans;
    return (int)ans; 
}

作为上述代码段的输入，m=53, n=4 的预期答案是 26235，但代码返回 26234。但是，标准输出显示 26235。

您能帮我理解这种行为吗？