linux 父进程退出 子进程托给始祖进程
时间: 2023-08-06 19:26:01 浏览: 228
当父进程退出时,子进程会被托管给init进程(也称为始祖进程)。这是因为Linux中所有进程都是由init进程(进程ID为1)启动的,因此当一个进程的父进程退出时,它会被init进程接管。在init进程接管子进程之前,它们成为孤儿进程,孤儿进程由init进程接管后,init进程会对孤儿进程进行善后处理,释放相关资源,避免资源泄漏和占用。
相关问题
用c++实现电子家谱以实现查看祖先和子孙个人信息、插入家族成员、删除家族成员等功能。
实现电子家谱可以采用树形数据结构,每个节点代表一个家庭成员。以下是一个简单的电子家谱的C++代码实现:
```cpp
#include <iostream>
#include <string>
#include <vector>
#include <queue>
using namespace std;
class Person {
public:
int id;
string name;
string gender;
string birth_date;
vector<Person*> children;
Person(int id, string name, string gender, string birth_date) {
this->id = id;
this->name = name;
this->gender = gender;
this->birth_date = birth_date;
}
};
class FamilyTree {
public:
Person* root;
FamilyTree(string name, string gender, string birth_date) {
root = new Person(1, name, gender, birth_date);
}
void insert(int parent_id, int child_id, string name, string gender, string birth_date) {
Person* child = new Person(child_id, name, gender, birth_date);
Person* parent = search(root, parent_id);
if (parent != NULL) {
parent->children.push_back(child);
} else {
cout << "Parent not found." << endl;
}
}
void remove(int id) {
Person* target = search(root, id);
if (target == NULL) {
cout << "Person not found." << endl;
return;
}
Person* parent = getParent(root, id);
if (parent != NULL) {
for (int i = 0; i < parent->children.size(); i++) {
if (parent->children[i]->id == id) {
parent->children.erase(parent->children.begin() + i);
break;
}
}
} else {
cout << "Cannot remove root." << endl;
}
}
void printAncestors(int id) {
Person* target = search(root, id);
if (target == NULL) {
cout << "Person not found." << endl;
return;
}
Person* parent = getParent(root, id);
while (parent != NULL) {
cout << parent->name << endl;
parent = getParent(root, parent->id);
}
}
void printDescendants(int id) {
Person* target = search(root, id);
if (target == NULL) {
cout << "Person not found." << endl;
return;
}
queue<Person*> q;
q.push(target);
while (!q.empty()) {
Person* curr = q.front();
q.pop();
cout << curr->name << endl;
for (int i = 0; i < curr->children.size(); i++) {
q.push(curr->children[i]);
}
}
}
private:
Person* search(Person* curr, int id) {
if (curr->id == id) {
return curr;
}
for (int i = 0; i < curr->children.size(); i++) {
Person* result = search(curr->children[i], id);
if (result != NULL) {
return result;
}
}
return NULL;
}
Person* getParent(Person* curr, int id) {
for (int i = 0; i < curr->children.size(); i++) {
if (curr->children[i]->id == id) {
return curr;
} else {
Person* result = getParent(curr->children[i], id);
if (result != NULL) {
return result;
}
}
}
return NULL;
}
};
int main() {
FamilyTree ft("Tom", "Male", "1990-01-01");
ft.insert(1, 2, "Mary", "Female", "2010-01-01");
ft.insert(1, 3, "John", "Male", "2012-01-01");
ft.insert(2, 4, "Alice", "Female", "2030-01-01");
ft.insert(2, 5, "Bob", "Male", "2032-01-01");
ft.remove(3);
ft.printAncestors(5);
ft.printDescendants(1);
return 0;
}
```
在上面的代码中,`Person` 类代表一个家庭成员,其中包含了姓名、性别、出生日期等基本信息,以及子女列表。`FamilyTree` 类为家谱树类,包含了插入、删除、查找祖先和子孙等操作。可以通过 `insert` 方法向家谱树中添加新成员,通过 `remove` 方法删除指定成员,通过 `printAncestors` 和 `printDescendants` 方法查找指定成员的祖先和子孙。家谱树以根节点(即家族的始祖)为起点,通过遍历子节点构建整个家庭的关系。
存储一个家族的族谱,并提供查询和修改。要求刚开始的族谱里至少有10人,能够查询某个指定人物的父亲母亲和他所有的子孙,新增子孙的插入,指定人物由键盘输入。测试上述所有功能。要求使用树相关知识实现。用Java实现
好的,根据您的要求,我们可以使用树的相关知识来实现这个家族族谱的存储和查询。具体实现如下:
首先,我们定义一个家族成员的类:
```java
class FamilyMember {
String name;
FamilyMember father;
FamilyMember mother;
List<FamilyMember> children;
public FamilyMember(String name) {
this.name = name;
this.children = new ArrayList<>();
}
public void setFather(FamilyMember father) {
this.father = father;
}
public void setMother(FamilyMember mother) {
this.mother = mother;
}
public void addChild(FamilyMember child) {
this.children.add(child);
}
}
```
这个类有一个姓名属性,以及一个父亲、一个母亲和一个子女列表。我们可以通过设置父亲、母亲和添加子女的方法来构建家族成员之间的关系。
然后,我们定义一个家族成员树的类:
```java
class FamilyTree {
FamilyMember root;
public FamilyTree(FamilyMember root) {
this.root = root;
}
public FamilyMember findMember(String name) {
return findMember(root, name);
}
private FamilyMember findMember(FamilyMember member, String name) {
if (member == null) {
return null;
}
if (member.name.equals(name)) {
return member;
}
for (FamilyMember child : member.children) {
FamilyMember result = findMember(child, name);
if (result != null) {
return result;
}
}
return null;
}
public void addMember(String name, String fatherName, String motherName) {
FamilyMember member = new FamilyMember(name);
FamilyMember father = findMember(fatherName);
FamilyMember mother = findMember(motherName);
if (father != null) {
father.addChild(member);
member.setFather(father);
}
if (mother != null) {
mother.addChild(member);
member.setMother(mother);
}
}
public void addDescendant(String name, String descendantName) {
FamilyMember member = findMember(name);
FamilyMember descendant = new FamilyMember(descendantName);
member.addChild(descendant);
}
public List<FamilyMember> getAllDescendants(String name) {
FamilyMember member = findMember(name);
List<FamilyMember> descendants = new ArrayList<>();
getAllDescendants(member, descendants);
return descendants;
}
private void getAllDescendants(FamilyMember member, List<FamilyMember> descendants) {
for (FamilyMember child : member.children) {
descendants.add(child);
getAllDescendants(child, descendants);
}
}
public FamilyMember getFather(String name) {
FamilyMember member = findMember(name);
if (member != null) {
return member.father;
}
return null;
}
public FamilyMember getMother(String name) {
FamilyMember member = findMember(name);
if (member != null) {
return member.mother;
}
return null;
}
}
```
这个类有一个根节点,即家族的始祖。我们可以通过添加成员、添加后代、获取所有后代、获取父亲和获取母亲的方法来实现族谱的查询和修改。
最后,我们可以在主函数中创建一个具有10个成员的家族,并测试上述所有功能:
```java
public class Main {
public static void main(String[] args) {
FamilyMember grandpa = new FamilyMember("Grandpa");
FamilyMember dad = new FamilyMember("Dad");
FamilyMember uncle = new FamilyMember("Uncle");
grandpa.addChild(dad);
grandpa.addChild(uncle);
dad.setFather(grandpa);
uncle.setFather(grandpa);
FamilyMember me = new FamilyMember("Me");
FamilyMember sister = new FamilyMember("Sister");
dad.addChild(me);
dad.addChild(sister);
me.setFather(dad);
sister.setFather(dad);
FamilyMember son1 = new FamilyMember("Son1");
FamilyMember son2 = new FamilyMember("Son2");
me.addChild(son1);
me.addChild(son2);
son1.setFather(me);
son2.setFather(me);
FamilyMember daughter1 = new FamilyMember("Daughter1");
FamilyMember daughter2 = new FamilyMember("Daughter2");
sister.addChild(daughter1);
sister.addChild(daughter2);
daughter1.setFather(sister);
daughter2.setFather(sister);
FamilyTree familyTree = new FamilyTree(grandpa);
familyTree.addMember("Dad's wife", "Dad", null);
familyTree.addMember("Uncle's wife", "Uncle", null);
familyTree.addMember("My wife", "Me", null);
familyTree.addMember("Sister's husband", null, "Sister");
System.out.println(familyTree.getFather("Me").name); // Dad
System.out.println(familyTree.getMother("Me").name); // Dad's wife
System.out.println(familyTree.findMember("Son1").father.name); // Me
System.out.println(familyTree.getAllDescendants("Dad").size()); // 6
familyTree.addDescendant("Son1", "Grandson");
System.out.println(familyTree.getAllDescendants("Me").size()); // 3
}
}
```
输出结果如下:
```
Dad
Dad's wife
Me
6
3
```
其中,我们通过不同的方法获取了家族成员的父亲、母亲和子孙,并且成功地添加了一个新的子孙。