結構指針數組

Question

編輯：我很新的c + +和編程整體。

我應該做一個程序，我使用stucts和一系列的結構。

安理會<>安全理事會

的會員我的任務是用「UML聚合」的概念來創建一個程序，我使用結構和結構數組。 （我希望你明白我想說什麼）

由於安全委員會的成員是安全委員會的成員，而不是相反，安全委員會的結構必須有一個安全委員會的結構成員。（多多包涵）

//example 
struct Member_sc{ 
    char * name; 
    int age; 
}; 
struct Security_council{ 
    Member_sc members[10];  
}; 

現在，我已經創建了這個程序，一切完美（根據我的老師），但現在，她告訴我，創建精確的複製，但不是的「成員」數組我必須使用指向Member_sc結構體的指針數組。由於我沒有完全弄清楚指針是如何工作的，所以我遇到了一些問題。

如果需要，我可以將代碼發佈到原始程序，但它包含4個文件（主文件頭，頭文件和一些函數文件），嘗試在此處發佈會很麻煩。

這裏是原型（全部在一個文件中，現在）你輸入後

#include <iostream> 
using namespace std; 

struct member_sc{ 
    string name; 
}; 

struct security_council{ 
    member_sc *point; 
    security_council **search; // ignore this for now 
    int n; 
    security_council():n(0){} 
}; 

void in_mem(member_sc &x){ 
    getline(cin,x.name); 
} 
void out_mem(member_sc &x){ 
    cout<<x.name<<endl; 
} 
void in_SC(security_council &q, member_sc &x){ 
    int num; //number of members 
    cin>>num; 
    for(int i=0; i<num; ++i){ 
     in_mem(x); 
     q.point[q.n]=x; 
     q.n++; 
     } 
} 
void out_SC(security_council &q,member_sc &x){ 
    for(int i=0; i<q.n; ++i){ 
     out_mem(q.point[i]); 
    } 
} 
int main(){ 

    member_sc y; 
    security_council x; 
    in_mem(y);    // works 
    out_mem(y);    // works 
    in_SC(x,y);    // crashes after i input the number of members i want 
    out_SC(x,y);   // 

    system("pause"); 
    return 0; 
} 

程序崩潰要讓成員在安理會的數量。 我的思維方式是對的嗎？或者我應該使用動態內存分配？

除此之外（我的老師給了我一個額外的任務）使用指針創建一個搜索函數。我認爲指針指針可能對此有好處，但我不確定。

任何幫助或建議將不勝感激。 （我覺得生病弄清楚搜索啄一次我想出的指針結構是如何工作的）

Answer 1

您的問題的第一部分是這樣的：

cin >> num; 

這個只讀取已經輸入，並在新行停止位。然後，在in_mem立即呼叫getline讀取換行符。你需要做的：

cin >> num; 
cin.ignore(); 

這將耗盡任何剩餘輸入的輸入流，或趕上這麼說。

但是，您的核心問題是您沒有爲「point」指定任何內存指向。

指針只是一個變量，它的值恰好是內存中某個事物的地址（從0開始偏移）。如果你要去機場並在便條上寫上「23號門」，那麼它的便條就是一個指針，「23號門」就是價值。

在你的代碼中，這個變量是未初始化的，如果你幸運的話，它可以是0，或者如果你不幸運，它可能是一些隨機地址。

對機場的比喻：你到達機場後發現你的便籤上寫有「比薩餅」。沒有幫助。

你的老師實際上已經指定了一個「數組指針」。打破下來：指向什麼？ member_sc，即member_sc*。現在讓一個數組

member_sc* pointers[10]; 

注意：這是不好的，現代C++ - 現代C++，你會用一種叫做智能指針（標準::的unique_ptr）可能。

std::unique_ptr<member_sc[]> pointers(new member_sc[10]); 

現在你有10個指針，而不是隻有一個，它們都需要一些分配指向。要做到這一點，最簡單的方法是用new關鍵字和拷貝構造函數：

for (int i = 0; i < num; i++) { 
    in_mem(x); 
    pointers[q.n] = new member_sc(x); // make a clone of x 
    q.n++; 
} 

或現代C++

for (int i = 0; i < num; i++) { 
    in_mem(x); // x is temporary for reading in 
    pointers[q.n] = std::make_unique<member_sc>(x); 
    q.n++; 
} 

然而，有這種方法的侷限性：只能有高達10個安全理事會成員。你如何解決這個問題？那麼，現代C++的答案是使用std::vector

std::vector<member_sc> members; 
// ditch n - vector tracks it for you. 

// ... 

for (int i = 0; i < num; ++i) { 
    in_mem(x); 
    q.members.push_back(x); 
    // q.n is replaced with q.members.size() 
    // which is tracked automatically for you 
} 

但我猜你的老師要你真正瞭解你的指針獲取有關他們忘記與現代豪華前。

我們需要重新使用上面我們剛剛使用的指針，並將「指針」更改爲指針數組。

這意味着我們需要一個指向member_sc指針集的指針。

member_sc** pointers; 

我們需要分配一些內存此指：

cin >> num; 
cin.ignore(); 
if (num == 0) { 
    // do something 
    return; 
} 
pointers = new member_sc[num]; 

幸運的是，使用指針數組是那麼容易，因爲使用數組，唯一的主要的區別在於你失去了數組大小的信息 - 你所擁有的僅僅是地址，而不是維度。

for (int i = 0; i < num; i++) { 
    in_mem(x); 
    q.pointers[i] = new member_sc(x); 
    q.n++; 
} 

我故意不給你一個完整的工作示例，因爲這顯然是一個類。

Answer 2

既然你被要求使用指針數組，這樣做：更換

Member_sc members[10]; 

與

Member_sc* members[10]; 

然後使用動態內存分配填充該數組。作爲一個好的形式，在程序結束時記得釋放你使用的動態內存。

Answer 3

您永遠不會初始化該成員指向的內存，然後在語句q.point[q.n]=x;中嘗試使用它。

基本上，在讀入成員數量之後，以及在單個成員中讀取的for循環之前，需要分配一個合適數量的member_sc對象的數組，並將其存儲在q.point中。不要忘記在完成使用後釋放這些內存。

一旦你這樣做，你也可以從in_SC和out_SC中刪除member_sc &x參數，因爲這將變得沒有必要。

最後，您的輸入的某些驗證似乎已到位。考慮如果用戶輸入一個負數，會發生什麼情況，並且您試圖直接使用它來確定要分配的內存大小。

---

這裏展示瞭如何使用結構的動態分配的數組一個簡單的例子：

#include <iostream> 
#include <string> 

struct member_sc { 
    std::string name; 
}; 

void test_array(int count) 
{ 
    if (count <= 0) { 
     return; // Error 
    } 

    // Allocate an array of appropriate size 
    member_sc* members = new member_sc[count]; 
    if (members == nullptr) { 
     return; // Error 
    } 

    // ... fill in the individual array elements 
    for(int i(0); i < count; ++i) { 
     // ... read from input stream 
     // I'll just generate some names to keep it simple 
     members[i].name = "User A"; 
     members[i].name[5] += i; // Change the last character, so we have different names 
    } 

    // Now let's try printing out the members... 
    for(int i(0); i < count; ++i) { 
     std::cout << i << ": " << members[i].name << "\n"; 
    } 

    delete[] members; 

} 


int main(int argc, char** argv) 
{ 
    for(int count(1); count <= 10; ++count) { 
     std::cout << "Test count=" << count << "\n"; 
     test_array(count); 
     std::cout << "\n"; 
    } 

    return 0; 
} 

Example on Coliru

---

當然，也有這種風格的代碼等諸多問題，但我相信這個問題不在話下。例如：

• 不使用裸指針，而是使用某種智能指針更合適。
• 而不是一個簡單的數組，使用某種集合，如向量。