在 C 或 C++ 中是否存在诸如锯齿状数组之类的东西？
当我编译这个：
int jagged[][] = { {0,1}, {1,2,3} };
我收到此错误：
错误：将“锯齿状”声明为多维数组必须具有除第一个维度之外的所有维度的边界
问问题
39708 次
11 回答
28
在 CI 中会使用一个指针数组。
例如：
int *jagged[5];
jagged[0] = malloc(sizeof(int) * 10);
jagged[1] = malloc(sizeof(int) * 3);
等等等等
于 2009-07-05T08:31:34.483 回答
18
There's a bunch of ways to do it. Here's another way:
int jagged_row0[] = {0,1};
int jagged_row1[] = {1,2,3};
int *jagged[] = { jagged_row0, jagged_row1 };
于 2009-07-05T08:58:26.283 回答
16
如果你只想初始化它，你可以说：
int jagged[][3] = { {0,1}, {1,2,3} };
但数组仍将具有 [2][3] 的形状。如果您想要一个真正的锯齿状数组，则必须动态创建它。如果你这样做，并且正在使用 C++，你应该使用 a std::vector，正如 friol 所建议的那样。
于 2009-07-05T08:17:48.847 回答
13
在C++中（未编译，可能有更紧凑的语法）：
std::vector<std::vector<int> > myArray;
myArray.push_back(std::vector<int>());
myArray.push_back(std::vector<int>());
myArray[0].push_back(0);
myArray[0].push_back(1);
myArray[1].push_back(1);
myArray[1].push_back(2);
myArray[1].push_back(3);
因此，现在您可以使用例如 myArray[0][0] 等来访问元素。
于 2009-07-05T08:21:38.963 回答
4
使用 C++11 初始化器列表，可以更紧凑地编写：
#include <vector>
#include <iostream>
int main() {
// declare and initialize array
std::vector<std::vector<int>> arr = {{1,2,3}, {4,5}};
// print content of array
for (auto row : arr) {
for (auto col : row)
std::cout << col << " ";
std::cout << "\n";
}
}
输出是：
$ g++ test.cc -std=c++11 && ./a.out
1 2 3
4 5
以供参考：
于 2014-11-12T19:14:58.367 回答
4
在 C99 中，您可以执行以下操作：
int jagged_row0[] = {0,1};
int jagged_row1[] = {1,2,3};
int (*jagged[])[] = { &jagged_row0, &jagged_row1 }; // note the ampersand
// also since compound literals are lvalues ...
int (*jagged2[])[] = { &(int[]){0,1}, &(int[]){1,2,3} };
这里唯一的区别（与rampion的答案相比）是数组不会衰减为指针，并且必须通过另一个间接级别访问单个数组 - （例如*jagged[0]- 并且必须记录每行的大小 - 即sizeof(*jagged[0])不会编译）-但它们看起来像是锯齿状的；）
于 2009-07-07T04:49:42.877 回答
4
您收到错误的原因是您必须至少为外部尺寸指定边界；IE
int jagged[][3] = {{0,1},{1,2,3}};
你不能让 jagged[0] 是一个 2 元素的 int 数组，而 jagged[1] 是一个 3 元素的 int 数组；N 元素数组与 M 元素数组（其中 N != M）的类型不同，并且数组的所有元素必须是相同类型。
您可以做的是其他人在上面建议的并将锯齿状创建为指向 int 的指针数组；这样每个元素都可以指向不同大小的整数数组：
int row0[] = {0,1};
int row1[] = {1,2,3};
int *jagged[] = {row0, row1};
尽管 row0 和 row1 是不同的类型（2 元素与 int 的 3 元素数组），但在初始化程序的上下文中，它们都被隐式转换为相同的类型 (int *)。
于 2009-07-17T15:28:40.850 回答
3
您还可以使用 c 中的复合文字来初始化一个真正的锯齿状数组，该数组在内存中是连续的，如下所示：
int (*arr[]) = { (int []) {0, 1}, (int []){ 2, 3, 4}, (int []){5, 6, 7, 8} }
这将在内存中连续排列。
于 2019-01-21T20:27:13.520 回答
1
//
//jaggedArrays.cpp
//
//program to implement jagged arrays in c++
//
#include<iostream>
#include<iomanip>
using namespace std;
int main()
{
int rows, i, j;
cout << endl << "Enter no of rows : ";
cin >> rows;
int columnsSizeOfEachRow[rows];
cout << endl;
for( i = 0 ; i < rows ; i++ )
{
cout << "Enter column size for row no " << i + 1 << " : ";
cin >> columnsSizeOfEachRow[i];
}
int *jaggedArray[rows];
for (i = 0 ; i < rows ; i++)
jaggedArray[i] = new int[columnsSizeOfEachRow[i]];
cout << endl;
for(i = 0 ; i < rows ; i++)
{
for ( j = 0 ; j < columnsSizeOfEachRow[i] ;j++)
{
cout << "Array[" << i + 1 << "][" << j + 1 << "] << ";
cin >> jaggedArray[i][j];
}
cout << endl;
}
cout << endl << endl << "Jagged array is as follows : " << endl;
for( i = 0 ; i < rows ; i++)
{
for ( j = 0 ; j < columnsSizeOfEachRow[i] ;j++)
cout << setw(3) <<jaggedArray[i][j] << " ";
cout << endl;
}
return 0;
}
于 2019-06-10T18:17:53.053 回答
1
通过在 cpp 中使用动态分配，我们可以创建锯齿状数组。
例如：
#include<iostream>
using namespace std;
int main(){
int n;
cout<<"Enter n:";
cin>>n;
cout<<"Enter elements:";
int **p = new int *[n];
for(int i=0;i<n;i++){
p[i] = new int[i+1];
for(int j=0;j<(i+1);j++){
cin>>p[i][j];
}
}
cout<<"Jagged Array:"<<endl;
for(int i=0;i<n;i++){
for(int j=0;j<(i+1);j++){
cout<<p[i][j]<<" ";
}
cout<<endl;
}
for(int i=0;i<n;i++){
delete []p[i];
}
delete []p;
}
对于n=3，我们创建了一个锯齿状数组，如下所示：
- 输入 n: 3
输入元素：
1
1 2
1 2 3
锯齿状阵列：
1
1 2
1 2 3
于 2020-09-14T10:25:03.197 回答
0
c++/c 中确实存在锯齿状数组，但语法非常复杂，您必须处理很多事情。
C++中有两种类型的交错数组。1) STATIC JAGGED ARRAY（一个二维数组，其中大小为常数，每行有不同的列数）。
2) DYNAMIC JAGGED ARRAY（一个二维数组，其大小可以是从用户那里获取的任意数字，并且每行的列数不同）
1）实现静态交错阵列的步骤
- 1）用你需要的行数声明一维数组
- 2）每个数组（行中元素的数组）的大小将是行中的列（或元素）数
- 3) 声明一个一维指针数组，该数组将保存箭头的地址
- 4）一维数组的大小是你想要的锯齿状数组中的行数
#include<iostream>
#include<string>
using namespace std;
int main()
{
int row0[4] = { 1,2,3,4 };
int row1[2] = { 5,6 };
int* jagged[2] = { row0,row1 };
int Size[2] = { 4,2 }, k = 0;
for (int i = 0; i < 2; i++)
{
int* ptr = jagged[i];
for (int j = 0; j < Size[k]; j++)
{
cout << *ptr << "";
ptr++;
}
cout << endl;
k++;
jagged[i]++;
}
return 0;
}
输出如下
1234
56
1）实现动态锯齿阵列的步骤
- 1）声明一个指针数组（锯齿状数组）
- 2）这个数组的大小将是锯齿状数组中所需的行数
- 3) 对于数组中的每个指针，为该行中所需的元素数分配内存。
#include<iostream>
#include<string>
using namespace std;
int main()
{
//2 rows
int* jagged[2];
//Allocate memeory for the elements in the row 0
jagged[0] = new int[1];
//Allocate memory for the elements in row 1
jagged[1] = new int[5];
//Array to hold the size of each row
int Size[2] = { 1,5 },k = 0, number = 100;
//User enters the numbers
for (int i = 0; i < 2; i++)
{
int* p = jagged[i];
for (int j = 0; j < Size[k]; j++)
{
*p = number++;
//move the pointer
p++;
}
k++;
}
k = 0;
//Display elements in Jagged array
for (int i = 0; i < 2; i++)
{
int* q = jagged[i];
for (int j = 0; j < Size[k]; j++)
{
cout << *q << "";
//move the pointer to the next element
q++;
}
cout << endl;
k++;
//move the pointer to the next row
jagged[i]++;
}
delete[] jagged[0];
delete[] jagged[1];
return 0;
}
输出如下
100
101102103104105
于 2020-10-13T10:26:27.447 回答