C++ 如何动态显示数组

我需要创建一个显示以下内容的函数：

if number is between 0 - 5 then display values 1, 2, 3, 4, 5
if number is between 5 - 10 then display values 2, 4, 6, 8, 10
if number is between 10 - 50 then display values 10, 20, 30, 40, 50
if number is between 50 - 100 then display values 20, 40, 60, 80, 100
if number is between 100 - 500 then display values 100, 200, 300, 400, 500
if number is between 500 - 1000 then display values 200, 400, 600, 800, 1000
if number is between 1000 - 5000 then display values 1000, 2000, 3000, 4000, 5000

等等

我考虑使用2个数组，然后乘以10

int *MyFunct(int number) {

    int a[5] = { 1, 2, 3, 4, 5 };
    int b[5] = { 2, 4, 6, 8, 10 };


    if (number >= 0 && number <= 5) {       
        return a;
    }   
    else if (number > 5 && number <= 10) {
        return b;
    }
    else if (number > 10 && number <= 50) {
        a[1] *= 10;
        a[2] *= 10;
        a[3] *= 10;
        a[4] *= 10;
        a[5] *= 10;
    }   
    .
    .
    .
}

int*MyFunct（整数）{
inta[5]={1,2,3,4,5}；
int b[5]={2,4,6,8,10}；
如果（number>=0&&number 5&&number 10&&number，您可以保留前两个数组。您可以通过3个步骤完成此操作

检查
number
是否介于
10^n和5*（10^n）
之间。如果介于10^n和5*（10^n）之间，请使用第一个数组。如果不在，请使用第二个数组

然后将每个数字乘以
10^n
，对于一些
n
，这样
10^n

这可以通过for循环来检查
我将从以下内容开始：

std::vector<unsigned int> MyFunct(unsigned int number) {
  std::vector<unsigned int> numbers = { 1,2,3,4,5 };
  unsigned int factor = 1;
  while(number >= 10)
  {
    number /= 10;
    factor *= 10;
  }
  if(number >= 5)
  {
    factor *= 2;
  }

  for(unsigned int i = 0; i < numbers.size(); ++i)
  {
    numbers[i] *= factor;
  }

  return numbers;
}

std:：vector MyFunct（无符号整数）{
向量数={1,2,3,4,5}；
无符号整数因子=1；
而（数字>=10）
{
数目/=10；
系数*=10；
}
如果（数字>=5）
{
系数*=2；
}
for（无符号整数i=0；i

您还可以使用以10为底的对数。
您必须首先注意，您不能返回自动数组。对于这个用例，最简单的方法是只使用静态数组

然后，您的算法可以改写为：


从数组开始
[1,2,3,4,5]
如果数字小于数组的最后一个数字，则返回数组
否则，将数组交替乘以2和5

在C++中给出了：

int *MyFunc(int n) {
    static const int init[] = {1, 2, 3, 4, 5};  // the initial array
    static int result[5];
    int& max = result[4];  // alias for the last value

    // copy init to result:
    for (int i=0; i<5; i++) result[i] = init[i];

    // find the range of n
    for (;;) {
        if (n <= max) {
            break;
        }
        // multiply alternatively by 2 and by 5
        for (int i=0; i<5; i++) result[i] *= 2; 
        if (n <= max) {
            break;
        }
        for (int i=0; i<5; i++) result[i] *= 5;
    }
    return result;
}

int*MyFunc（int n）{
static const int init[]={1,2,3,4,5}；//初始数组
静态int结果[5]；
int&max=result[4]；//最后一个值的别名
//将初始化复制到结果：
对于（int i=0；i这里有一个变量，它执行您所说的应该执行的操作–显示这些输出–而不是返回数组。

它根本不使用任何数组。

（请注意，上述问题包含重叠间隔。我假设间隔实际上为0-5、6-10、11-50、51-100、101-500、501-1000和>1000。）

以及
factor
的一种变体，它使用一个表而不是一长串条件：

int factor(int x)
{
    struct interval { int limit; int factor; };
    interval intervals[] = {{1000, 1000},
                            {500, 200},
                            {100, 100},
                            {50, 20},
                            {10, 10},
                            {5, 2}};
    for (auto i: intervals)
    {
        if (x > i.limit)
        {
            return i.factor;
        }
    }
    return 1;
}

作业？\这里的范围有冲突。0-5和5-10？不能两者都有5。将指针返回到本地数组是未定义的行为。返回的指针将在其指向的数据被销毁时使用。您的程序很可能崩溃。代码中也有一个大问题。访问该数组的方式数组的所有元素都不正确。它应该是
a[0]*=10；a[1]*=10；
即…它应该从
0
开始，而不是
1
。此外，
a[5]
在数组中不存在。
1 2 3 4 5
2 4 6 8 10
10 20 30 40 50
20 40 60 80 100
100 200 300 400 500
200 400 600 800 1000
1000 2000 3000 4000 5000

int factor(int x)
{
    struct interval { int limit; int factor; };
    interval intervals[] = {{1000, 1000},
                            {500, 200},
                            {100, 100},
                            {50, 20},
                            {10, 10},
                            {5, 2}};
    for (auto i: intervals)
    {
        if (x > i.limit)
        {
            return i.factor;
        }
    }
    return 1;
}