结构指针数组

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

---

当然，也有这种风格的代码等诸多问题，但我相信这个问题不在话下。例如：

• 不使用裸指针，而是使用某种智能指针更合适。
• 而不是一个简单的数组，使用某种集合，如向量。