C++ 将字符串重新定义为类

我必须将字符串重新定义为类，并且对运算符+重载或复制构造函数都有问题。My main（）编译，但不提供任何东西或涂鸦作为回报。下面是类字符串的片段：

class String {
  char *nap;
  public:

  String(const char* ns){
    nap=strcpy(new char[strlen(ns)+1],ns);
  }
  String(const String & n){
    nap=strcpy(new char[strlen(n.nap)+1],n.nap);
  }
  String operator+(const String& n) const;
  String operator+(const char* ns) const;

  //operator=
  String& operator=(const String &n){
      if(this==&n)
        return *this;
  delete []nap;
  nap= strcpy(new char[strlen(n.nap)+1],n.nap);
  return *this;
  }
  //...
  friend String operator+(const char*, const String&);
  friend ostream& operator<<(ostream&, const String&);
  };

 String String::operator+(const String& s) const{
 return String(nap+*s.nap);
}
String String:: operator+(const char* c) const{
return String(nap+*c);
}
 String operator+(const char* c,const String & s){
 return String(String(s)+String(c));
}
ostream &operator<<(ostream& os,const String& s){
 os<<s.nap<<endl;
 return os;
}

类字符串{
字符*nap；
公众：
字符串（常量字符*ns）{
nap=strcpy（新字符[strlen（ns）+1]，ns）；
}
字符串（常量字符串（&n）{
nap=strcpy（新字符[strlen（n.nap）+1]，n.nap）；
}
字符串运算符+（常量字符串&n）常量；
字符串运算符+（常量字符*ns）常量；
//接线员=
字符串和运算符=（常量字符串和n）{
如果（此==&n）
归还*这个；
删除[]nap；
nap=strcpy（新字符[strlen（n.nap）+1]，n.nap）；
归还*这个；
}
//...
友元字符串运算符+（常量字符*，常量字符串&）；
friend ostream&operator在operator+中调用（或更好），而不是添加指针。
或者自己将一个nap的字节复制到另一个nap的末尾。
在这两种情况下，您必须确保分配了足够的内存！
加法运算符在我看来不正确

*
操作符可以被读取为的内容。因此
*s.nap
实际上是
s.nap
的内容，它是一个
char
字符，表示
nap
指向的第一个字符。因此
nap+*s.nap
不是您想要的，也不是
nap+*c

您的类还需要一个析构函数来确保指向的内存
nap
被删除。
类字符串{
class String {
  char *nap;

public:
  // Default argument is nifty !!
  String(const char* ns=""){
    nap=strcpy(new char[strlen(ns)+1],ns);
  }
  // !! Don'te forget to delete[] on destruction
  ~String() {
      delete[] nap;
  }

  String(const String & n){
    nap=strcpy(new char[strlen(n.nap)+1],n.nap);
  }

  String operator+(const String& n) const;

  // Not necessary since String(const char *) exists
  // an expression like String+"X" will be casted to String+String("X")

  // String operator+(const char* ns) const;

  //operator=
  String& operator=(const String &n){
      if(this==&n)
        return *this;
      delete []nap;
      nap= strcpy(new char[strlen(n.nap)+1],n.nap);
      return *this;
  }

  //...
  friend String operator+(const char*, const String&);
  friend std::ostream& operator<<(std::ostream&, const String&);
  };
 // Make enough space for both strings
 // concatenate
 // !! delete the buffer  
 String String::operator+(const String& si) const {
    char *n = new char [strlen(nap)+strlen(si.nap)+1];
    strcpy(n,nap);
    strcpy(n+strlen(nap),si.nap);
    String so = String(n);
    delete [] n;
    return so;
 }

// Not necessary. Since String(const char *) exists
// String String:: operator+(const char* c) const{
// return String(nap+*c);
// }

String operator+(const char* c,const String & s){
 return String(String(s)+String(c));
}

std::ostream &operator<<(std::ostream& os,const String& s){
 os<<s.nap<<std::endl;
 return os;
}

字符*nap；
公众：
//默认参数是漂亮的！！
字符串（常量字符*ns=”“）{
nap=strcpy（新字符[strlen（ns）+1]，ns）；
}
//！！不要忘记在销毁时删除[]
~String（）{
删除[]nap；
}
字符串（常量字符串（&n）{
nap=strcpy（新字符[strlen（n.nap）+1]，n.nap）；
}
字符串运算符+（常量字符串&n）常量；
//不需要，因为字符串（const char*）存在
//类似字符串+“X”的表达式将被强制转换为字符串+字符串（“X”）
//字符串运算符+（常量字符*ns）常量；
//接线员=
字符串和运算符=（常量字符串和n）{
如果（此==&n）
归还*这个；
删除[]nap；
nap=strcpy（新字符[strlen（n.nap）+1]，n.nap）；
归还*这个；
}
//...
友元字符串运算符+（常量字符*，常量字符串&）；
friend std:：ostream&Operator使用此
nap+*s.nap
您不是在连接字符串，而是在指向char
（char*）
的指针上添加了一个偏移量。您添加的值是
s.nap
指向的第一个字符的整数值。生成的指针用于构造新字符串。因为它指向“某处”在内存中，您最终会得到一个垃圾字符串（或内存冲突）…嘿，首先感谢您的快速响应。其次，我编写了类似字符串string:：operator+（const char*c）const{return string（strcpy（new char[strlen（c）+1]，c））；}这是你的意思吗？如果是这样，我怎么能把朋友的操作中的字符串连接起来？很不幸，我对下面的语言例子很熟悉。你似乎更喜欢JavaHiSE背景。记住C++中你完全负责内存管理，除非你用特殊的包装器来做指针。最后一件事，如果请您解释一下strpy（n+strlen（nap），si.nap）的原因和作用。我对strlen（nap）这件事感到困惑。它在n+streng（nap）之后附加si.nap。您当前的缓冲区是
n
您已经将
nap
复制到
n
中，现在您必须在
nap
的副本之后复制
si.nap
。
class String {
  char *nap;

public:
  // Default argument is nifty !!
  String(const char* ns=""){
    nap=strcpy(new char[strlen(ns)+1],ns);
  }
  // !! Don'te forget to delete[] on destruction
  ~String() {
      delete[] nap;
  }

  String(const String & n){
    nap=strcpy(new char[strlen(n.nap)+1],n.nap);
  }

  String operator+(const String& n) const;

  // Not necessary since String(const char *) exists
  // an expression like String+"X" will be casted to String+String("X")

  // String operator+(const char* ns) const;

  //operator=
  String& operator=(const String &n){
      if(this==&n)
        return *this;
      delete []nap;
      nap= strcpy(new char[strlen(n.nap)+1],n.nap);
      return *this;
  }

  //...
  friend String operator+(const char*, const String&);
  friend std::ostream& operator<<(std::ostream&, const String&);
  };
 // Make enough space for both strings
 // concatenate
 // !! delete the buffer  
 String String::operator+(const String& si) const {
    char *n = new char [strlen(nap)+strlen(si.nap)+1];
    strcpy(n,nap);
    strcpy(n+strlen(nap),si.nap);
    String so = String(n);
    delete [] n;
    return so;
 }

// Not necessary. Since String(const char *) exists
// String String:: operator+(const char* c) const{
// return String(nap+*c);
// }

String operator+(const char* c,const String & s){
 return String(String(s)+String(c));
}

std::ostream &operator<<(std::ostream& os,const String& s){
 os<<s.nap<<std::endl;
 return os;
}