主页 / 问题 / 876604
Accepted
Adokenai
Asked:2020-09-03 12:58:10 +0000 UTC2020-09-03 12:58:10 +0000 UTC

如何告诉编译器用相同的非空值填充静态数组？

  • 772

一种基本的方法：在初始化期间填充数组。但是该数组是静态的，并且已经占用了图像中的空间。您需要以某种方式告诉编译器用特定值填充数组的区域。代码static int arr[5]={1}填写为{1, 0, 0, 0, 0}，但需要{1, 1, 1, 1, 1}

__attribute__((fillupper(1)))被 gcc 忽略。

该数组是非常量的。一个有 5 个元素的数组就是一个例子。您需要填充 4096 个元素的数组。STL 功能的使用受到严格限制，包括衍生产品。它们都有第一句话中指出的基本解决方案。

编辑答案：

template <typename type, type v>
struct IArray {
  type val = v;
  IArray& operator=(type n){
    val=n;
    return *this;
  }
  IArray& operator|=(type n){
    val|=n;
    return *this;
  }
};

您需要为所需的转换添加/更改运算符。

c++

5 个回答

  1. 不要打我。只找到了asm一种方法。

    //> g++ -std=c++11 memset.cpp
#include<iostream>

asm(  
"   .globl  s2\n"
"   .data\n"
"   .align 32\n"
"   .type   s2, @object\n"
"   .size   s2, 16384\n"
"s2: .fill 4096,4,777\n"
);

extern "C" { extern int s2[4096]; };

int main(){
  for(size_t j = 4096+1;j>0;){--j; std::cout<<"s2["<<j<<"]="<<s2[j]<<" ";}
  std::cout<<"s2["<<-1<<"]="<<s2[-1]<<std::endl;  }

    错误答案： 使用memset很容易。例子：

    //> g++ -std=c++11 -S memset.cpp
#include <string.h>
int main(){
  int m[4096]{};
  int n[4096];
  memset(n,1,4096);
  }

    结果将是代码：

    subq    $32768, %rsp
leaq    -32768(%rbp), %rax
movl    $16384, %edx
movl    $0, %esi
movq    %rax, %rdi
call    memset
leaq    -16384(%rbp), %rax
movl    $4096, %edx
movl    $1, %esi
movq    %rax, %rdi
call    memset

    如您所见，没有区别，只有 0 和 1 。

    • 4

  2. GCC 支持非标准语法

    static int arr[4096] = { [0 ... 4095] = 1 };

    但这是指定初始化器功能的扩展，即 这是 C，不是 C++。

    也就是说，如果此选项适合您，则可以在 C++ 项目中使用

    int arr[4096] = { [0 ... 4095] = 1 };

    并且在 C++ 代码中已经添加

    extern "C" int arr[4096];

    如果你愿意捐赠static。

    • 3
  3. Best Answer
    #include <iostream>

template <int v>
struct Int {
    int val = v;
};

int main() {
    Int<10> arr[1024];
    std::cout << arr[10].val << std::endl;
}

    https://godbolt.org/z/6-BEPi

    • 3 
  4. dd if=/dev/zero of=/tmp/sarr conv=swab count=4096
xxd -i /tmp/sarr | sed -e 's/0x00/0x01/g' > /tmp/parr.h

    PS :)

    升级版：

    #include <iostream>

template <typename T, size_t N, T def_val>
class ct_array {
public:
    constexpr explicit ct_array();

public:
    const T& operator[](size_t idx) const;

protected:
    T m_data[N];
};

template <typename T, size_t N, T def_val>
constexpr ct_array<T, N, def_val>::ct_array()
    : m_data()
{
    for (T *el = m_data; el != m_data + N; ++el)
        *el = def_val;
}

template <typename T, size_t N, T def_val>
const T& ct_array<T, N, def_val>::operator[](size_t idx) const {
    return m_data[idx];
}

template <typename T, size_t N, T def_val>
constexpr decltype(auto) make_ct_array() {
    return ct_array<T, N, def_val>();
}

int main() {
    constexpr auto arr = make_ct_array<int, 1024, 0x01>();
    std::cout << arr[10] << std::endl;
    return 0;
}

    UPD2：

    #include <iostream>

template <typename T, size_t N>
class ct_array {
public:
    constexpr explicit ct_array(T def);

public:
    const T& operator[](size_t idx) const;

protected:
    T m_data[N];
};

template <typename T, size_t N>
constexpr ct_array<T, N>::ct_array(T def)
    : m_data()
{
    for (T *el = m_data; el != m_data + N; ++el)
        *el = def;
}

template <typename T, size_t N>
const T& ct_array<T, N>::operator[](size_t idx) const {
    return m_data[idx];
}

template <typename T, size_t N>
constexpr decltype(auto) make_ct_array(T def) {
    return ct_array<T, N>(def);
}

int main() {
    constexpr auto arr = make_ct_array<double, 1024>(3.14);
    std::cout << arr[10] << std::endl;
    return 0;
}
    • 1

  5. 你可以写一个函数

    template <class T>
void f(T a[], size_t s, const T& n)
{
     for (size_t i = 0; i < s; ++i)
         a[i] = n;
}

    然后

    const int n = 4096;
int arr[n];
f(arr, n, 1);

    调用它后你会得到想要的结果

    或者使用标准算法

    const int n = 4096;
int arr[n];
std::fill(arr, arr + n, 1);
    • 0

相关问题