如果没有n常量或constexpr，就不能使用char arr[n]。
您不需要map。set就足够了。
请注意，map和set已经删除了重复项，然后可以检查是否插入了任何元素，以使新字符串与第一个字符串的顺序相同，如下所示

#include<string>
#include<iostream>
#include<unordered_set>

std::string removeDuplicates(const std::string &s){
    std::string arr;
    std::unordered_set<char> exists;

    for(const auto&el:s)
        if(exists.insert(el).second) arr+=el;

    return arr;
}

//driver code
int main(){
    std::string str;
    std::cin >> str;
    std::cout<<removeDuplicates(str)<<std::endl;
    return 0;
}

std::string支援移除元素。

#include <iostream>
#include <string>

std::string removeDuplicates(std::string str) {
    for (int i = 0; i < str.size(); i++) {
        while (true) {
            int j = str.find_last_of(str[i]);
            if (i < j) {
                str.erase(j, 1);
            } else {
                break;
            }
        }
    }
    return str;
}

int main() {
    std::cout << removeDuplicates("ARRUN");
    return 0;
}

如果函数声明如下所示

char* removeDuplicates(string &s,int n);

那么它意味着传递的对象本身将在函数中被改变。否则参数应该有限定符const。
此外，还不清楚为什么函数具有返回类型char *。看起来函数的声明是矛盾的。
函数的第二个参数应至少具有size_t类型或更好的std::string::size_type类型。int类型无法容纳std：：string：：size_type类型的所有值。
可以在没有第二个参数的情况下声明函数。
一种不使用需要动态内存分配的中间容器的简单方法如下所示

#include <iostream>
#include <string>

std::string & removeDuplicate( std::string &s )
{
    const char *p = s.c_str();

    std::string::size_type pos = 0;

    for ( std::string::size_type i = 0, n = s.size(); i < n; i++ )
    {
        std::string::size_type j = 0;
        while ( j < pos && s[i] != s[j] ) j++;

        if ( j == pos )
        {
            if ( i != pos ) s[pos] = s[i];
            ++pos;
        }
    }

    return s.erase( pos );
}

int main() 
{
    std::string s( "H e l l o" );

    std::cout << "\"" << s <<"\"\n";

    std::cout << "\"" << removeDuplicate( s ) <<"\"\n";

    return 0;
}

程序输出为

"H e l l o"
"H elo"

@Arun Suryan：您说对了，但是您可以不使用向量，使用全局字符数组来完成

另外，不要忘记在末尾附加newline！

下面是一个例子：

#include<string>
#include<iostream>
#include<unordered_map>

char* removeDuplicates(std::string &s,int n){

    std::unordered_map<char,int> exists;
    char* arr = (char*)(malloc(n*sizeof(char)));
    int index = 0;
    for(int i=0;i<n;i++){
        if(exists[s[i]]==0)
        {
            arr[index++] = s[i];
            exists[s[i]]++;
        }
    }
    arr[index] = '\n';
    return arr;
}

//driver code
int main(){
    std::string str;
    std::cin >> str;
    std::cout<<removeDuplicates(str,str.length())<<std::endl;
    return 0;
}

对于C++新手来说，这可能有点高级，但另一种解决方案利用了erase-remove idiom：

std::string removeDuplicates(const std::string& s) {
    std::string result = s;
    std::unordered_set<char> seen;

    result.erase(std::remove_if(result.begin(), result.end(), [&seen](char c)
        {
            if (seen.find(c) != seen.end())
                return true;

            seen.insert(c);
            return false;
        }),
    result.end());

    return result;
}

它基本上使用一个集合来存储已经看到的字符，将要删除的字符向下移动到尾部（使用std::remove_if），并从字符串中擦除尾部。
工作版本here。

这也是可行的，一个具有内置功能的单线解决方案。
cout<<str.erase(std::unique(str.begin(), str.end()), str.end());

简单答案

#include<bits/stdc++.h>
using namespace std;
string removeduplicate(string key){
    set<char>s;
    string ans="";
    for(int i=0;i<key.size();++i){
        if(s.find(key[i])==s.end()){
            s.insert(key[i]);
            ans.push_back(key[i]);
        }
    }
    return ans;

}


int main()
{
    string key="";
    cout<<"enter the key:";
    cin>>key;
    string ans1=removeduplicate(key);
    cout<<ans1;
    return 0;
}

所以，在网上读了一些东西之后，我意识到我试图在removeDuplicates()函数中返回一个指向本地数组的指针。
这是工作正常的方法

#include <bits/stdc++.h>
using namespace std;
void removeDuplicates(string &s,int n){
    vector<char> vec;
    unordered_map<char,int> exists;
    int index = 0;
    for(int i=0;i<n;i++){
        if(exists[s[i]]==0)
        {
            vec.push_back(s[i]);
            exists[s[i]]++;
        }
    }
    for(auto x: vec)
        cout << x;
}

//driver code
int main(){
    string str;
    cin >> str;
    removeDuplicates(str,str.length());
    return 0;
}

PS：我们也可以把函数的返回类型设置为向量。