小编pen*_*gon的帖子

有没有办法将a vector::iterator转换为指针而无法访问向量本身？仅当vector可用时才有效:

typedef vector<int> V;
int* to_pointer1( V& v, V::iterator t )
{
    return v.data() + (t-v.begin() );
}

但是如何在没有vector周围的情况下完成这项工作？这不起作用:

int* to_pointer2( V::iterator t )
{
    // the obvious approach doesn't work for the end iterator
    return &*t;
}

事实上,我本来希望这是一个非常基本和流行的问题,但由于某种原因,我找不到它.

给出类模板

template<class T>
struct A {
    A( const T & x );
};

我想在不写出实际类型的情况下实例化此类的对象T,因为这通常是由某种表达式模板和lambda函数产生的笨拙类型.实现这一目标的一种方法是

template<class T>
A<T> create_A( const T& t ){ 
    return A<T>( t );
}

int main(){
    auto a = create_A( complicated_expression );
}

在这里,我从未编写过表达式的实际类型,但是A如果没有复制构造函数,这将创建一个副本并且无法工作.我没有复制(或移动)构造函数.我正在寻找的是类似的东西

A a( complicated_expression );

干净简单,编译器应该能够找出实际的类型.不幸的是,这不是有效的C++.那么完成同样的事情最有效的C++语法是什么？目前我这样做:

auto x = complicated_expression;
A<decltype(x)> a(x);

但这似乎没有必要冗长.有一个更好的方法吗？

我有一个 tensorflow 模型，它采用不同大小的输入图像：

inputs = layers.Input(shape=(128,None,1), name='x_input')

<tf.Tensor 'x_input:0' shape=(?, 128, ?, 1) dtype=float32>

当我将此模型转换为 tensorflow-lite 时，它​​会抱怨：

converter = tf.lite.TFLiteConverter.from_frozen_graph(
  graph_def_file, input_arrays, output_arrays)
tflite_model = converter.convert() 

ValueError: None is only supported in the 1st dimension.
Tensor 'x_input_1' has invalid shape '[None, 128, None, 1]'.

我无法将图像缩放到固定大小。我看到的唯一解决方案是将图像填充到某个最大尺寸并在图表中使用该尺寸，但这似乎很浪费。有没有其他方法可以使 tensorflow-lite 与动态图像尺寸一起工作？这个限制有什么理由吗？谢谢。

我想将一个double值打印成一个不超过8个字符的字符串.打印的数字应尽可能多,例如

5.259675
48920568
8.514e-6
-9.4e-12

我试过C++ iostreams和printf-style,并且都没有像我希望的那样尊重提供的大小:

cout << setw(8) <<  1.0 / 17777.0 << endl;
printf( "%8g\n", 1.0 / 17777.0 );

得到:

5.62525e-005
5.62525e-005

我知道我可以指定一个精度,但我必须在这里提供一个非常小的精度,以便覆盖最坏的情况.任何想法如何在不牺牲太多精度的情况下强制确切的场宽？我需要这个用于打印矩阵.我真的需要提出自己的转换功能吗？

5年前也提出了类似的问题:将double转换为固定宽度的String,没有令人满意的答案.我当然希望在此期间取得一些进展.

给定一个版本号数组，如下所示：

vector<string> v = { "9.8.17.5295", "9.13.0.0",
                          "12.3.9.1017", "25.3.6.1" };

在 C++ 中对它们进行排序的最佳方法是什么？当然，这里的问题是，我们不能只按字典顺序对它们进行排序，而是必须将每个字符串拆分为多个组件，并按数字方式比较这些组件。在 Python 中可以这样完成：

v.sort(key=lambda x : tuple(map( int, x.split('.'))))

但如何在 C++ 中做到这一点呢？与这一行相比，我能想出的任何东西看起来都相当麻烦。到目前为止我发现的最好的是：

array<int, 4> splitversion( const string& s )
{
    array<int, 4> z;
    sscanf( s.c_str(), "%d.%d.%d.%d", &z[0], &z[1], &z[2], &z[3] );
    return z;
}

int main()
{
    vector<string> v = { "9.8.17.5295", "25.3.6.1", "9.13.0.0", "12.3.9.1017" };
    sort( v.begin(), v.end(), []( string s1, string s2 )
          { return splitversion( s1 ) < splitversion(  s2 ); } );
}

当然，sscanf …

简短的故事:我需要一个可以存储无限数量元素的容器,但是不需要为少量元素分配动态内存.

长话:我需要存储几个整数,其数量不受限制,但很少超过两三个.我尝试使用vector<int>或list<int>,但与简单阵列相比,性能在发布模式下至少为50,在调试模式下为500.例如,我测量了创建一个vector,调用push_back三次,并再次销毁它.这需要大约250ns.reserve(3)提前呼叫有点帮助,时间降到100ns.使用数组需要3ns,但我不能使用固定大小的数组,因为元素的数量是无限的.我需要存储很多这些东西,作为较大对象的一部分.

所以我想我要求的是一个使用某种小矢量优化的容器:只要元素的数量很少,它们就存储在对象本身中,并且只有当它超过某个限制时才会分配内存.在堆上.这样的事情存在吗？

作为一个侧节点,basic_string众所周知有这种优化,所以我试过了basic_string<int>.实际上,对于3的大小,它比它快四倍vector<int>,但不知何故使用字符串类来存储整数感觉不对.再说一遍,我的问题是:是否有一些容器在小尺寸上表现良好,但如果需要可以无限增长？

编辑人们要求提供实际代码.嗯,没有什么特别的,它是直截了当的.我无法发布它,因为它是大型基准测试环境的一部分,具有用于计时的特殊用途类,以及用于模糊代码以防止编译器替换它的一些类{}.你知道,当它注意到结果没有被使用时就会这样做.它的核心归结为:

vector<int> v;
v.push_back(17);
v.push_back(19);
v.push_back(23);

和

int x[3];
int k = 0;
x[k++] = 17;
x[k++] = 19;
x[k++] = 23;

每个都在一个紧密的定时循环中运行.

EDIT2这个用例是一个树,每个节点有一个可变数量的分支.所以我实际上需要存储指针而没有整数,但这是32位,所以两者都是相同的大小.这一点很重要,因为树会不断修改.

Edit3人们不断怀疑我的数字.为什么你认为他们不合理？A vector做动态内存分配,数组没有,这似乎是差异的一个很好的解释,或者不是吗？

此代码无效且无法编译:

struct A { int x; };

struct B : public A {};

void f( B** p ){
    A** pa = p; // type mismatch
}

虽然它看起来很无辜,但似乎可以使用reinterpret_cast.我知道有些情况下这不会那么简单,例如涉及多重继承时,但在这种特殊情况下,应该没有任何问题,编译器应该能够解决这个问题.那么为什么在C++中不允许这样做呢？reinterpret_cast考虑到上面给出的类型,这是一个绕过这个限制的好方法吗？