对一个成绩关系型数据集采用半自动化方法生成5匿名发布数据，并且能够展示出5匿名数据结果，该数据集含有姓名、性别、语文成绩、数学成绩、外语成绩、平均成绩，用C++实现

这个问题需要使用数据处理和算法知识来解决。一般情况下，我们可以使用k-匿名方法来对数据进行匿名处理。

步骤如下：

1. 对于每个人的记录，将姓名和性别作为辨别唯一性的标识符，其他特征值作为属性。

2. 对于属性值进行离散化处理，将其划分为一定数量的区间。

3. 对于每个人的记录，将其属性值替换为所在区间的编号。

4. 对于每个记录，找到与之最相似的k个记录，并将它们划分到同一个组内。

5. 对于每个组，将其中所有记录的属性值随机置换，但是保持每个组内的属性值分布相同。

6. 最后，将处理后的数据发布。

下面是一个简单的C++实现：

#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <algorithm>
#include <ctime>
#include <cstdlib>

using namespace std;

const int k = 3; // 设置k值
const string input_file = "data.txt"; // 输入文件
const string output_file = "anonymous_data.txt"; // 输出文件

struct Record {
    string name;
    string gender;
    int chinese;
    int math;
    int english;
    int average;
};

struct Group {
    vector<Record> records;
    map<int, vector<int> > index; // 用于查找相似记录
};

vector<Record> read_data() {
    vector<Record> data;
    ifstream fin(input_file);
    string line;
    getline(fin, line); // 第一行是标题，忽略
    while (getline(fin, line)) {
        Record record;
        sscanf(line.c_str(), "%s %s %d %d %d %d", &record.name, &record.gender, &record.chinese, &record.math, &record.english, &record.average);
        data.push_back(record);
    }
    fin.close();
    return data;
}

void write_data(const vector<Record>& data) {
    ofstream fout(output_file);
    fout << "name,gender,chinese,math,english,average" << endl;
    for (auto record : data) {
        fout << record.name << "," << record.gender << "," << record.chinese << "," << record.math << "," << record.english << "," << record.average << endl;
    }
    fout.close();
}

bool compare_by_attributes(const Record& a, const Record& b) {
    if (a.chinese != b.chinese) {
        return a.chinese < b.chinese;
    }
    if (a.math != b.math) {
        return a.math < b.math;
    }
    if (a.english != b.english) {
        return a.english < b.english;
    }
    if (a.average != b.average) {
        return a.average < b.average;
    }
    return false;
}

vector<Group> group_records(const vector<Record>& data) {
    vector<Record> sorted_data(data);
    sort(sorted_data.begin(), sorted_data.end(), compare_by_attributes);
    vector<Group> groups;
    for (auto record : sorted_data) {
        bool added = false;
        for (auto& group : groups) {
            bool similar = true;
            for (auto index : group.index) {
                int attribute_id = index.first;
                vector<int> indices = index.second;
                int other_value = record.average;
                int this_value = group.records[indices[0]].average;
                if (other_value < this_value - k || other_value > this_value + k) {
                    similar = false;
                    break;
                }
            }
            if (similar) {
                group.records.push_back(record);
                for (auto& index : group.index) {
                    int attribute_id = index.first;
                    vector<int>& indices = index.second;
                    int value = record.average;
                    int this_value = group.records[indices[0]].average;
                    if (value < this_value - k || value > this_value + k) {
                        indices.push_back(group.records.size() - 1);
                        break;
                    }
                }
                added = true;
                break;
            }
        }
        if (!added) {
            Group group;
            group.records.push_back(record);
            for (int i = 0; i < 4; i++) {
                vector<int> indices;
                indices.push_back(0);
                group.index[i] = indices;
            }
            groups.push_back(group);
        }
    }
    return groups;
}

void anonymize_data(vector<Group>& groups) {
    for (auto& group : groups) {
        int n = group.records.size();
        for (int i = 0; i < n; i++) {
            int j = rand() % n;
            swap(group.records[i], group.records[j]);
        }
    }
}

int main() {
    srand(time(NULL));
    vector<Record> data = read_data();
    vector<Group> groups = group_records(data);
    anonymize_data(groups);
    vector<Record> anonymous_data;
    for (auto group : groups) {
        for (auto record : group.records) {
            anonymous_data.push_back(record);
        }
    }
    write_data(anonymous_data);
    return 0;
}

注意，这个代码只是一个简单的示例，不能保证完全正确。实际上，还需要进行更多的测试和调试才能确保它的正确性。