标签: static-array

我没有C或C++的背景,所以静态数组让我有点困惑.它们适用于什么？为什么他们分配在堆栈上？

我想有一个性能优势.堆栈分配更快,不需要垃圾回收.但为什么在编译时需要知道长度？难道你不能在运行时创建一个固定大小的数组并在堆栈上分配它？

D中的动态数组或切片由包含指针和长度属性的结构表示.静态数组是一样的吗？他们是如何代表的？

如果将它们传递给函数,它们将被完整复制(除非你使用ref),这背后的基本原理是什么？

我意识到动态数组和切片在D中比静态数组更加重要,这就是为什么文档没有详细讨论它们,但我仍然希望有更多的背景知识.我想静态数组的特性与堆栈分配的工作方式有关.

目标:

我想为不经常更改的数据实现硬编码查找表,但是当它确实发生更改时,我希望能够快速更新程序并重建.

计划:

我的计划是定义一个自定义数据类型...

private class ScalingData
{
    public float mAmount;
    public String mPurpose;
    public int mPriority;

    ScalingData(float fAmount, String strPurpose, int iPriority)
    {
        mAmount = fAmount;
        mPurpose = strPurpose;
        mPriority = iPriority;
    }
}

然后,在主类中,像这样对数组进行硬编码......

public static ScalingData[] ScalingDataArray =
{
        {1.01f, "Data point 1", 1},
        {1.55f, "Data point 2", 2}
};

但是,这不构建.我一直看到消息" Type mismatch: cannot convert from float[] to ScalingData".

我怎样才能实现目标？

UPDATE

到目前为止,我已尝试实施这些建议,但仍然遇到错误......

代码如下:

public class CustomConverter
{
    //Lookup Table
    private static ScalingData[] ScalingDataArray =
    {
        new …

我正在开发的系统中有很多类,在这些类中,我有一个关于某些东西的"名称"的数组.名称最多30个字符.

最初我只使用了10个字符,但现在我需要增加限制.增加限制需要时间,因为我在很多地方使用这种数组.如果我使用#define NAME_SIZE 30或类似的东西会更容易,然后我所要做的就是改变一个数而不是大约二十个.

但是我不确定这是否是C++中的"合法"事情.

这将节省我未来的大量时间,这就是我要问的原因.

我试图在TEnumerator中公开构建私有静态数组.

Delphi本身允许直接枚举静态数组(见下文),所以我怀疑Delphi在后台为静态数组创建一个枚举器,我希望我能够在GetEnumerator方法中创建和公开相同的枚举器.

(我使用的是Delphi XE2).

program Project6;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.Generics.Collections;

type
  TMyEnum = (meA, meB);

  TMyClass = class
  private
    FItems: array[TMyEnum] of Integer;
  protected
  public
    function GetEnumerator: TEnumerator<Integer>;
  end;

{ TMyClass }

function TMyClass.GetEnumerator: TEnumerator<Integer>;
begin
  // What is the simplies way of creating this enumerator?
end;

var
  myObj: TMyClass;
  i: Integer;

begin
  myObj := TMyClass.Create;
  try
    // This works but only in the same unit
    for i in myObj.FItems do
      WriteLn(i);

    for i in myObj do …

如何定义我的类中所有方法都可访问的STATIC数字数组？

根据C++中静态数组与动态数组的正确答案,静态数组具有固定的大小.

但是,这个编译并运行得很好:

int main(int argc, char** argv) {

int myArray[2];

myArray[0] = 0;
myArray[1] = 1;

cout<<myArray[0]<<endl;
cout<<myArray[1]<<endl;

myArray[4];

myArray[2] = 2;
myArray[3] = 3;

cout<<myArray[2]<<endl;
cout<<myArray[3]<<endl;

return 0;
}

这是否意味着可以调整静态数组的大小？

我有一个枚举的全局数组变量'a'..'z'.如果我想在变量声明中初始化一些条目,我通常会执行以下操作:

var 
  Example: Array['a'..'z'] of String = ('Example one', 'two', 'three');

有没有办法在变量声明中初始化,例如'g','p','o'和'y',或者我必须通过实现部分中的某个函数/过程来执行此操作？

有没有更聪明的方法来实现我想要的？

如何创建支持任何大小的静态数组的函数？

就像是:

@safe pure nothrow void fillArray(ref ubyte[] array) {
    /**
     * How do I make this function support arrays of any
     * size; but they don't have to be dynamic?
    **/
}

如果我调用该函数

/** Check if all Elements, possibly recursively, of $(D x) are zero. */
bool allZero(T)(in T x) @safe pure nothrow {
    import std.range: isIterable;
    static if (isIterable!T) {
        foreach (ref elt; x) {
            if (!elt.allZero) { return false; }
        }
        return true;
    } else {
        return x == 0;
    }
}

使用静态数组,D会foreach在发布模式下自动为我展开吗？

如果不能

/** Static Iota. */
import std.typetuple: TypeTuple;
template siota(size_t from, size_t to) { alias siotaImpl!(to-1, from) siota; }
private template siotaImpl(size_t to, size_t now) …

我有一个指向函数的静态数组指针作为类的成员.

我需要对它进行初始化,但事实证明这个数组的长度是64K项,因此使用静态初始化器初始化它是不切实际的,就像{ x, y, z, ... }它会使代码混乱一样.

我反而用代码初始化它,有几个循环.

我想要这样做的方法是static在构造函数中初始化数组并为其设置一个标志,因此只有该类的第一个实例的构造才会触发此初始化.

从实例中访问这个静态标志也不是线程安全的,但这是另一个故事.

有更干净或更好的方法吗？

我也想要这个数组const,但我担心唯一的方法就是static {}初始化,对吗？

我有一个带有静态char数组的类.数组的大小是给我的argv.

我想做这样的事情:

class ABC {

public:
  static char *buffer;
  ABC(int size) {
    ABC::buffer = new char[size];
  }

}

// in other file:

ABC tempVar(atoi(argv[1]));

但这似乎不起作用.我得到的错误如下:

错误2错误LNK2001:解析外部符号:(？缓冲@ ABC @@ 2PADA) "公共静态字符*ABC ::缓冲区" gpslib.lib

我怎样才能解决这个问题？

所以我有一个C++结构,它有一个静态数组作为成员,我想在构造函数中询问它的大小.正如我从本文http://msdn.microsoft.com/en-us/library/4s7x1k91(VS.71).aspx所理解的那样,sizeof可以应用于静态数组以查找整个大小(以字节为单位)数组,而不仅仅是它的类型.但是,当我sizeof()对成员执行时,它给出了4(指针的大小)而不是数组的大小.这是上下文(平凡的):

struct A
{
    char descirption[128];
    int value;

    A(const char desc[], int val)
    {
        size_t charsToCopy = std::min(sizeof(description), sizeof(desc));
        memcpy(description, desc, charsToCopy);
        value = val;
    }
}

int main()
{
    A instance("A description string", 1);
    //now instance has a description string that says "A des" followed by garbage characters
}

那么我如何获得成员char数组的大小？

编辑

当我在编译器中放置一个断点并检查这两个值时sizeof(description),sizeof(desc)我看到了sizeof(description) == 4,和sizeof(desc) == 21.因此我的困惑.因为我正在将一个字符串文字传递给构造函数,所以编译器似乎很高兴告诉我传入的字符串的实际大小.如果我将它分配给某个地方的某个变量,可能就不会这样了,但是现在我我试图追查根本问题:sizeof(some-member-static-array)给了我一些(相对)毫无意义的东西.

sizeof是否可能正在进行某种字符串长度测量,因为它是一组字符？