返回數組

Question

如何返回指向數組的指針並從中獲取值？

int * getChange(int first[], int second[], int SIZE) { 
    int i = 0; 
    int * change = new int[2]; 
    for (i = 0; i < SIZE; i++) { 
     if (first[i] != second[i]) { 
      change[0] = first[i]; 
      change[1] = second[i]; 
     } 
     break; 
    } 
    return change; 
} 

function main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    int * change; 
    change = getChange(possibilities, myNumbers, 4); 
    printf("%i/%i\n", (change), (change+1)); 
} 

不幸的是，功能似乎返回地址，而不是值...

Answer 1

試圖改變

printf("%i/%i\n", (change), (change+1)); 

到

printf("%i/%i\n", *(change), *(change+1)); 

在printf功能，你需要使用一個int作爲參數，而不是一個int*。 change變量是一個指針。您必須使用*change，並使用指針算法，*(change + 1)

顯然，不要忘記釋放分配的內存。

Answer 2

printf("%i/%i\n", (change), (change+1)); 

這應該是：

printf("%d/%d\n", *change, *(change + 1)); 

Answer 3

int* functionReturningArray(int *inputArray, int size) 
{ 
    int*outputArray = new int[20]; 
    return outputArray; 
} 

但是，在C++和c樣式數組中使用vector要好得多。因爲它可以保護你免受很多錯誤的影響，並且使用矢量編寫代碼的速度更快。 也這樣functionReturningArray不是很好，因爲它只返回一個指向數組的第一個元素的指針，但不返回大小。您可以通過預定義他們傳遞指針給他們你的函數像這樣返回的大小和指針（兩個參數）：

void f(int**outputArray, int *size) 
{ 
    *outPutArray = new int[20]; 
    *size = 20; 
} 

而且它的外觀與向量：

std::vector<int> func(const std::vector<int> &input) 
{ 
    std::vector<int> output; 
    output.push_back(5); 
    return output; 
} 

你也可以在堆上創建矢量並返回指向它的指針。 但是避免使用std :: vector - 使用std :: string來替代

Answer 4

我想我會寫一點不同的（並且注意我在C++中只使用C概念 - 在C++中我幾乎可以肯定做事情有點不同）：

void getChange(int *first, int *second, int SIZE, int *change) { 
    int i = 0; 
    for (i = 0; i < SIZE; i++) { 
     if (first[i] != second[i]) { 
      change[0] = first[i]; 
      change[1] = second[i]; 
      break; 
     } 
    } 

    return;  
} 

function main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    int change[2]; 
    getChange(possibilities, myNumbers, 4, change); 
    printf("%i/%i\n", change[0], change[1]); 
} 

如果分配change外面的getChange你解決潛在的內存泄漏問題。

Answer 5

在C++中，你不會使用數組（int[]或int*）來的，因爲他們在幾個方面都討厭：你必須通過SIZE各地，他們通常異常不安全（你必須捕獲異常，刪除數組，然後重新拋出異常），並且很難正確使用它作爲類成員。使用標準庫容器或迭代器範圍。

慣用的方式做你想要做的是使用迭代器和對什麼：

template <typename IT_1, typename IT_2> 
std::pair<int,int> getChange(IT1 begin, IT1 end, IT2 begin2) 
{ 
    for (; begin != end; ++begin, ++begin2) 
    { 
    if (*begin != *begin2) return std::make_pair(*begin,*begin2); 
    } 
    return std::make_pair(0,0); 
} 

void main() { 
    int myNumbers[] = {1, 0, 2, 3}; 
    int possibilities[] = {0, 1, 2, 3}; 
    std::pair<int,int> change = getChange(possibilities, possibilities + 4, 
              myNumbers); 
    printf("%i/%i\n", change.first, change.second); 
} 

注意，第二序列（通過myNumbers）預計爲至少只要是作爲第一序列。如果你與迭代器和函數模板不舒服的是，你可以隨時使用向量來代替：

std::pair<int,int> getChange(std::vector<int> a, std::vector<int> b) { 
    for (int i = 0; i < a.size() && i < b.size(); ++i) 
    { 
    if (a[i] != b[i]) return std::make_pair(a[i],b[i]); 
    } 
    return std::make_pair(0,0); 
} 

void main() { 
    int _myNumbers[] = {1, 0, 2, 3}; 
    int _possibilities[] = {0, 1, 2, 3}; 

    std::vector<int> myNumbers(_myNumbers,_myNuymbers+4), 
        possibilities(_possibilities,_possibilities+4); 

    std::pair<int,int> change = getChange(possibilities, myNumbers); 
    printf("%i/%i\n", change.first, change.second); 
} 

而後者似乎而非陣列版本更詳細的（畢竟，它創建兩個數組，然後複製將它們的值寫入向量中），請記住從一個常量初始化一個數組是非常罕見的事情：大多數情況下，數組（和向量）是由一段代碼專門用於動態初始化的。這樣的代碼通常可以用於數組和矢量，只需很少的更改。

而且，當然，如果您最終使用它們的話，您可以將typedef均設爲std::pair<int,int>和std::vector<int>更短的名稱。

Answer 6

正如前面所說，你的代碼在很多層次上都是非常錯誤的。我會盡力解釋。

首先，如果你想返回相同的數組，你爲什麼要創建一個新的？你想要做什麼，到底是什麼？

其次，你所做的新事物永遠不會被釋放。在main（）退出後，應用程序的所有內存都將被操作系統聲明，但不應該依賴於此。

即Chowlett寫正確的代碼（+1是不錯的，並指出了分配問題），所以我就通過你的代碼，並指出東西

for(int i = 0 ; i < size i++) 
{ 
    if(first[i] != second[i]) 
    { 
     change[0] = first[i]; 
     change[1] = second[i]; 
    } 
    break; 
} 

一點不做你想做的事。它檢查第一個[0]是否與第二個[0]不同，然後點擊是否成立。你想要在if語句塊內進行分解。

那麼如果你想使用一個數組的內容，你必須用[]索引它，否則你引用數組的內存地址，它是索引。這意味着它一直說，你想要做

printf("%d/%d", changed[0], change[1]) 

在什麼上面，使用C++向量是這種情況下比數組「更好」，我不認爲這是正確的回答你的問題說： 。你似乎在學習如何使用數組，而數組是C甚至C++實際生活編碼中最重要的部分。你會使用它們很多，它們比矢量更快，許多很多很多庫都是用純C編寫的，所以你必須使用它們。

學習一點點指針算術，你會沒事的。記住釋放你分配的內存，這不是Java。記住，一個在

int a[3]; 

更像是一個

int *a; 

不是像一個

int a; 

這就解釋了爲什麼你也可以做

printf("%d/%d", *changed, *(changed + 1)); 

閱讀Kernighan和裏奇。 快樂黑客

---