2

有没有办法从函数返回数组？更具体地说，我创建了这个函数：

char bin[8];

for(int i = 7; i >= 0; i--)
{
    int ascii='a';
    if(2^i-ascii >= 0)
    {
        bin[i]='1';
        ascii=2^i-ascii;
    }
    else
    {
        bin[i]='0';
    }
}

我需要一种方法来返回bin[]。

4

9 回答 9

8

你不能这样做，但你可以：

  • 返回一个动态分配的数组——最好由智能指针拥有，这样调用者就不必关心为它释放内存——你也可以通过这种方式返回类似 std::vector 的东西。
  • 通过指针（建议）或非常量引用填充作为参数传递给您的数组/向量。
于 2009-05-10T18:31:54.853 回答
3

您的数组是分配在堆栈上的局部变量。您应该使用new []它在堆上分配它。然后你可以说：return bin;。请注意，delete []当你完成它时，你必须明确地释放它。

于 2009-05-10T18:33:07.223 回答
2

你真的问错问题了。如果您想在 C++ 中进行字符串处理，请使用 std::string 和/或 std::vector 类，而不是 char 数组。然后您的代码变为：

vector <char> func() {
    vector <char> bin(8);
    for( int i = 7; i >= 0; i-- ) {
       int ascii='a';
       if ( 2 ^ i - ascii >= 0 ) {
          bin[i] = '1';
          ascii = 2^i - ascii;
       }
       else {
        bin[i] ='0';
       }
    }
    return bin;
}
于 2009-05-10T18:32:51.107 回答
1

我认为你最好的选择是使用向量。它可以像数组一样以多种方式运行，并且有几个优点（长度与类型一起存储，自动内存管理）。 

void Calculate( std::vector<char>& bin) {
  for(int i = 7; i >= 0; i--)
  {
    int ascii='a';
    if(2^i-ascii >= 0)
    {
        bin.push_back('1');
        ascii=2^i-ascii;
    }
    else
    {
        bin.push_back('0');
    }
  }
}
于 2009-05-10T18:37:05.033 回答
1

如果要返回数组的副本（可能对小数组有意义）并且数组具有固定大小，则可以将其包含在结构中；

struct ArrayWrapper {
   char _bin[8];
};

ArrayWrapper func()
{
    ArrayWrapper x;

    // Do your stuff here using x._bin instead of plain bin

    return x;
}

或者只是使用已经建议的 std::vector 。

于 2009-05-10T18:47:05.763 回答
1

与@ari 的回答类似，我想说已经有一个提升解决方案，boost::array可以解决您的问题：

boost::array<char, 8> f() {
    boost::array<char, 8> bin;
    for(int i = 7; i >= 0; i--) {
        int ascii = 'a';
        if(2 ^ i-ascii >= 0) {
            bin[i] = '1';
            ascii = 2 ^ i-ascii;
        } else {
            bin[i] = '0';
        }
    }
}

...
boost::array<char, 8> a(f());

[虽然我不确定你想用那个算法做什么，但请注意，我认为你想做1 << i（按位移位）而不是2 ^ iC ++中的幂运算。]

Boost 数组是一个普通数组，只是包装在一个结构中，所以你不会失去任何性能。std::array它也将在下一个 C++ 版本中begin()作为size(). data()只需使用最基本的一个：

template<typename T, size_t S>
struct array { 
    T t[S];
    T& operator[](ptrdiff_t i) { return t[i]; }
    T const& operator[](ptrdiff_t i) const { return t[i]; }
};

但像往常一样，使用其他人已经编写的工具，在这种情况下boost::array。它还具有聚合的优点（这就是它没有用户声明的构造函数的原因），因此它允许使用大括号括起来的列表进行初始化：

boost::array<int, 4> a = {{ 1, 2, 3, 4 }};
于 2009-05-10T19:09:33.683 回答
0

您需要在函数中将数组 bin 作为参数传递。 数组总是按地址传递，因此您不需要返回任何值。它会自动向您显示主程序中的所有更改

void FunctionAbc(char bin[], int size);


void FuncationAbc(bin, size)
{
for(int i = 7; i >= 0; i--)
{
    int ascii='a';
    if(2^i-ascii >= 0)
    {
        bin[i]='1';
        ascii=2^i-ascii;
    }
    else
    {
        bin[i]='0';
    }
}

}
于 2009-05-10T18:33:16.037 回答
0

您需要通过引用传递，如下所示：

void modifyBin(char (&bin)[8])
{
    /* your function goes here and modifies bin */
}

int main() 
{
    char bin[8];
    modifyBin(bin);
    /* bin has been updated */
    return 0;
}
于 2009-05-10T18:39:27.697 回答
0

我认为其他人都回答了这个问题……使用容器而不是数组。这是std::string版本：

std::string foo() {
    int ascii = 'a';
    std::string result("00000000");
    for (int i=7; i>=0; --i) {
        if (2^i-ascii >= 0) {
            result[i] = '1';
            ascii = 2^i-ascii;
        }
    }
    return result;
}

我不确定2^i-ascii你是否想要。这将被解析为(2 ^ (i - ascii))有点奇怪。

于 2009-05-10T18:43:29.000 回答