n次元ポインタはどのように定義（宣言）すればよいのでしょうか？

Question

例えば，3次元の char 型ポインタでしたら，

char ***ptr;

と表現すれば良いと思うのですが，これが例えば，次のソースコードのように変数dimの値によって，dim次元の char 型ポインタを定義したい場合，どのように記述すればよいのでしょうか？

void func(int dim)
{
  // dim次元の char 型ポインタ ptr を定義したい
  
  return;
}

void main(void)
{
  int dim=3;
  func(dim);
}

どなたかわかる方いらっしゃいましたら，教えていただきたいです．

Comments

[maisumakun]

なぜそのようなことが必要になったのでしょうか？

[yuki]

n次元配列のメモリ確保をする関数を作成したく，その際に，整数引数dimによってdim次元ポインタを定義する必要がありました．

例えば，3次元配列のメモリ確保関数ですと，次のようになります．

define ALLOC_CUBIC(T,U,V,W) (T***)AllocCubic(sizeof(T),U,V,W)
void*AllocCubic(int s, int u, int v, int w)
{
int i,j;
int t=s*w, p=sizeof(char*);
char ***a,**b,*c;

a=(char***)malloc(p*u + p*u*v + s*u*v*w);
if(a){
b=(char**)(a+u);
c=(char*)(b+u*v);
}else return 0;

for(i=0;i<u;i++){
a[i]=b;
for(j=0;j<v;j++){
b[j]=c;
c+=t;
}
b+=v;
}
return a;
}

3次元とわかっていれば，
char ***a,**b,*c;
また，4次元とわかっていれば，
char ****a,***b,**c,*d;
と定義すればよいのですが，dim次元の場合，どのように定義すればよいのか知りたく，質問させていただきました．

[thkana]

一応...
型 **a;は二次元配列とは関係ありませんし、
型 ***b;は三次元配列とは別物です。
*がn個ついたポインタはn次元のデータ構造を表すのに使えますがn次元のポインタとは呼びませんし、それで表されるデータ構造はCの用語において決して「n次元配列」と呼ばれるものではありませんので勘違いなきよう。
(Javaだったらちょっと事情は違うかもしれませんが。)

[yominet]

コーディング段階で動的な次元数のポインタ変数の定義はできないといったことは、
他の方の回答で済んでいると思うので、動的な次元数を扱う選択肢の提案を。
使用が許されるのであれば、OpenCVのMatを使うという手も。
データにアクセスするためのat()等も準備されてます。
内部的には連なったメモリでアクセスも早いと思います（計っていないですが）

Answer 1

文字通りにはどうしようも無いので、void *で宣言しておいて、参照の際に必要に応じてキャストするのでしょうか。

Answer 2

実行速度などの要件がシビアでなければHow can i create an n-dimensional array in cでの回答はいかがでしょうか。

• 常に1次元の領域を確保する。
• n次元→1次元上の配列位置を算出してアクセスする。

とする手法です。

Comments

[asm]

むしろCPUが上手いことやってくれそうな分
多重ポインタよりも速く、ポインタ分省メモリ と要件シビアなほど1次元化が有利な気がしますね
(乗算器がない場合などには話変わりますが・・・)

[8524ba23]

コンパイル後のコードやCPUなどの低水準の知識がないので、位置算出のコストが大きくなりそうで気になったのですが、そうなんですね。
提示URLでも走査パターンやアルゴリズムを工夫することで位置算出コストを減らすことができる可能性があることも示されていますから、案外よい手法かも。

Answer 3

C++初心者なので，下記はクソみたいなコードですが，
何かこんな感じのをもっとまともに作れないものですかね？

class SomeDimArray
{
public:
    //ctor
    //各次元のサイズと，何次元なのかを指定
    SomeDimArray( const size_t *Sizes, size_t Dim )
        : m_Dim(Dim)
    {
        if( Dim>1 )
        {   m_LowerLV.assign( Sizes[0], SomeDimArray( Sizes+1, Dim-1 ) );   }
        else
        {   m_Vals.assign( Sizes[0], 0 );   }
    }

    size_t Dim() const {    return m_Dim;   }

public:
    //要素アクセス手段(const版は省略)
    //1次元じゃないときは()でアクセスし，
    //1次元のときは[]でアクセスするという…
    SomeDimArray &operator()( int idx ){   return m_LowerLV[idx];  }
    int &operator[]( int idx ){ return m_Vals[idx]; }

private:
    size_t m_Dim;  //次元
    //以下のどっちかを持つ
    std::vector<int> m_Vals;    //自分が1次元だったらここにデータ値を持つ
    std::vector<SomeDimArray> m_LowerLV;    //自分が (k>1)次元 だったら， (k-1)次元のやつらをここに持つ
};

//main
int main(void)
{
    //３次元配列を作ってみるよ
    size_t Sizes[] = { 2,3,4 };
    SomeDimArray A( Sizes, 3 );

    //要素アクセス．
    A(0)(1)[2] = 9; //嫌な書き方だ…

    return 0;
}

Answer 4

C/C++では型はコンパイル時に決定していないといけませんので
ご質問のように仮引数によって動的に型を決定する事はできません。

---

C++においてはテンプレートによって作れました。
が、前述のようにコンパイル時にDimが決定されている必要があったりと実用的かは微妙です

#include <array>

template <typename T, size_t Dim>
struct NPtr{
    typedef NPtr<T,Dim-1>::type* type;
};

template <typename T>
struct NPtr<T,0>{
    typedef T type;
};

template<typename T, size_t Dim, typename... Args>
NPtr<T, Dim>::type AllocDim(Args... _width){
    static_assert(Dim == sizeof...(_width), "sizeof...(_width) must equal Dim");
    std::array<size_t, Dim> width = {_width...};
    size_t elements = 1, points = 0;
    for(size_t i = 0; i < Dim; i++) {
        points += elements;
        elements *= width[i];
    }
    points -= 1;
    size_t size = elements * sizeof(T) + points * sizeof(void**);
    void* result = malloc(size);
    if(!result)
        return nullptr;
    void** it = (void**)result;
    char* data = (char*)(it+points);
    size_t memo = 0;
    size_t t = 1;
    for(size_t i = 0; i < Dim-2; i++) {
        size_t w = width[i], diff = width[i+1];
        memo += w;
        t *= w;
        void** base = it;
        for(size_t l = 0; l < t; l++) {
            *it++ = (void*)(base + memo + l * diff);
        }
    }
    size_t last = width[Dim-1];
    for(size_t i = 0; it < (void**)data; i++) {
        *it++ = (void*)(data + last * i * sizeof(T));
    }
    return (typename NPtr<T, Dim>::type) result;
}

int main(){
    char*** ptr = AllocDim<char, 3>(3,2,2);
}

Answer 5

そもそもの問題として、STLのvectorを使ってはだめでしょうか。
使ってよいのであれば、いちいち、AllocCubicなどの実装する必要はありません。

例えば、3次元であれば以下になります。
STLのstringを使った版も入れてあります。

#include <string>
#include <vector>
using namespace std;

int main(void) {
    int U, V, W;
    int size;
    // 3次元
    vector<vector<vector<vector<char>>>> s1(
        U, vector<vector<vector<char>>>(
               V, vector<vector<char>>(W, vector<char>(size))));
    // stringを使用
    vector<vector<vector<string>>> s2(
        U, vector<vector<string>>(V, vector<string>(W)));
    return 0;
}

Comments

[fana]

> 例えば、3次元であれば…

とのことですが，
本件の問題点とは「その次元が未知である（動的に与えられる）ときに，どうすればよいのか？」という話と見えます．
その点を解決する回答になっているのでしょうか？

[akiruno-oneone]

そもそもとお断りをしたのは、型は動的に宣言できないと思います。
質問のなかで、3次元配列ををマクロで定義されています。
vectorを使用すれば、いちいち質問のなかで回答されているような新しい関数を定義する必要はないと考えます。
その使い方から、別の案を提示しました。

[fana]

[質問への追記・修正、ベストアンサー選択の依頼] にて示されている AllocCubic/ALLOC_CUBIC は，
「3次元とわかっていれば」このような実装ができるが…　という話の上での例でしかなく，このAllocCubicの別の形の実装が必要とされているわけではありません．

「静的に定まる次元数3の配列」をvectorを用いて実現する話というのは，
例えば，
「動的に与えられる場合は無理です．（←とりあえずこれが回答だとして）
　ところで，それはそれとして，そのAllocCubicのようなものはvectorを用いれば…」
みたいに触れられるような，質問への回答ではないサブの話題かと．