C++ c++；类型转换数组

如何将int数组转换为float数组？ 谢谢。

你不能

您必须创建另一个数组，并使用循环手动复制元素

---

<>在C++中，编译器通常不在结果二进制文件中插入循环，而不必在代码中显式地看到。

如果你有一个数组，代码代码> s，你基本上有一个N个代码块INT/INSCOR>S，它在内存中连续存储。然而，一个浮点数组将是连续存储在内存中的N个浮点，即内存中完全不同的位序列。此外，浮点值在二进制中的表示方式与整数值完全不同。事实上，您甚至不能确定

int

的大小是否与

浮点相同。

因此，在处理数组时，您必须将每个

int

分别强制转换为

float

，或者通过复制原始数组来创建一个完全不同的数组

例如，在处理数组时，可以简单地将每个int转换为浮点：

int array[100];
// ... fill array with some values

for (int i = 0; i < 100; ++i)
{
  float f = array[i]; // implicit conversion here 
  // now do something with this float
}

int数组[100]；
// ... 用一些值填充数组
对于（int i=0；i<100；++i）
{
float f=array[i]；//此处进行隐式转换
//现在用这个浮子做点什么
}

如果使用向量而不是数组，则可以使用向量构造函数中的迭代器进行复制

std::vector<int> vi;
vi.push_back(1);
vi.push_back(2);
vi.push_back(3);

std::vector<float> vf(vi.begin(), vi.end());
assert(vf.size() == 3);

---

---

注意：

std:：copy

，并且向量构造函数不会盲目复制内存，它将在每个元素的两种类型之间隐式强制转换。它执行赋值*result=*first、*（result+1）=*（first+1）等等…

IMO，使用transform并将int-vector转换为float-vector

float convert (int i) { return static_cast<float>(i); }

int main () {
  int first[10];
  float second[10];
    // set some values:
  for (int i=0; i<10; i++) 
      first[i] =  (i*10); 

  transform (first, first + 10, second, convert);

  return 0;
}

float convert（inti）{return static_cast（i）；}
int main（）{
int first[10]；
浮动秒[10]；
//设置一些值：
对于（int i=0；i
#包括
#包括
#定义N 50
int main（）{
int intArray[N]={…}；
浮点数组[N]；
std:：copy（intArray，intArray+N，floatArray）；
标准：：cout
使用c++17和
std:：array
（或任何类似的类），这个问题一般都可以解决

template <typename Y, typename X, std::size_t N, template <typename, std::size_t> typename A, std::size_t... Is>
constexpr A<Y, N> elements_cast(const A<X, N> &a, std::index_sequence<Is...>) {
    return {std::get<Is>(a)...};
}

template <typename Y, typename X, std::size_t N, template <typename, std::size_t> typename A, typename Indices = std::make_index_sequence<N>>
constexpr A<Y, N> elements_cast(const A<X, N> &a) {
    return elements_cast<Y>(a, Indices{});
}

或者你可以使用std：：copy，并让它在赋值时为你隐式转换。
std：：copy
在这里可以做的隐式转换就足够了；
std：：transform
可以工作，但没有必要。
static\u cast
也没有必要。为什么定义N而不仅仅是int N=50；？它的主要风格不再是定义一种预处理器命令，它在编译时定义一个值，所有出现的值都用该值的文本替换。它还避免创建变量，这在更复杂的程序中有许多好处。另一种解释如下：
float convert (int i) { return static_cast<float>(i); }

int main () {
  int first[10];
  float second[10];
    // set some values:
  for (int i=0; i<10; i++) 
      first[i] =  (i*10); 

  transform (first, first + 10, second, convert);

  return 0;
}

#include <algorithm>
#include <iostream>

#define N 50

int main() {
    int intArray[N] = { ... };
    float floatArray[N];
    std::copy(intArray, intArray + N, floatArray);
    std::cout
        << std::boolalpha << std::equal(intArray, intArray + N, floatArray)
        << std::endl;
    return 0;
}

template <typename Y, typename X, std::size_t N, template <typename, std::size_t> typename A, std::size_t... Is>
constexpr A<Y, N> elements_cast(const A<X, N> &a, std::index_sequence<Is...>) {
    return {std::get<Is>(a)...};
}

template <typename Y, typename X, std::size_t N, template <typename, std::size_t> typename A, typename Indices = std::make_index_sequence<N>>
constexpr A<Y, N> elements_cast(const A<X, N> &a) {
    return elements_cast<Y>(a, Indices{});
}

std::array<int, 5> array_of_ints;
auto array_of_floats = elements_cast<float>(array_of_ints);