编写一个程序，可以将英语规则名词由单数变成复数

1．一般名词复数是在名词后面加上“s”，如map→maps， bag→bags等；

2．以s， sh， ch， x等结尾的词加“es”，如bus→buses， watch→watches等；

3．以辅音字母＋y结尾的词，变y为i加es，如baby→babies等；以元音字母＋ y结尾的名词变复数时，直接加s变复数，如monkey→monkeys， holiday→holidays， storey→storeys（楼层）；

4．以o 结尾的名词变复数时：

a）加s的名词有：photo→photos ，piano→pianos， radio→radios， zoo→zoos

b）加es的名词有：

potato→potatoes, tomato→tomatoes ,hero-> heroes

5．以f或fe结尾的名词变复数时：

a）加s的名词有：

belief→beliefs roof→roofs

safe→safes gulf→gulfs

b）去掉f， fe 加ves的名词有：

half→halves knife→knives

leaf→leaves wolf→wolves

wife→wives life→lives thief→thieves

不规则变化：（常见的有）

child-> children

foot-> feet

tooth-> teeth

man->men

woman-> women

以上只是部分总结，详见语法书

#include<iostream>

#include<string>

using namespace std;

class Complex{

private:

double m_real;

double m_complex;

public://各个函数的定义。

Complex(double real=00,double complex=00);

void Setnumber();

Complex operator+(Complex &object);

Complex operator-(Complex&);

Complex operator(Complex &);

Complex operator/(Complex &);

bool operator==(Complex &);

void Display();

};

Complex::Complex(double real,double complex)

{

m_real=real;

m_complex=complex;

}

void Complex::Setnumber()//定义设置函数。

{

/cout<<"input the real part of the number:";

cin>>m_real;

cout<<"input the complex part of the number:";

cin>>m_complex;/

string s;

int i=1,flag=2,flag1=0;

m_real=m_complex=0;

cout<<"input the number:";//采用的输入字符串，根据字符串中的各个字符来判断实部和虚部。

cin>>s;

while(i<=ssize())

{

if(s[i-1]=='-'&&i==1)

i++;

if(s[i-1]<=57&&s[i-1]>=48)

{

(flag==2m_real:m_complex)=10;

(flag==2m_real:m_complex)+=s[i-1]-48;

}

else

{

if(s[i-1]=='i')

flag=1;

else

flag=0;

if(s[i-1]=='-')

flag1=1;

}

i++;

}

//后面就是要判段是否要变号，因为要考虑的很多，所以分了情况进行实现。

if(m_real==0&&m_complex==0)//如果都为0，这是上面漏掉了-i和+i两种情况，在这里补上。

m_real=1;

if(s[0]=='-')//如果实部是负数。

m_real=-1;

if(flag1==1)//如果复数的虚部是负数。

m_complex=-1;

if(flag==1&&flag1==0&&m_complex==0)//如果没有实部只有虚部。

{

m_complex=m_real;

m_real=0;

}

}

//下面就是一些重载 *** 作符的实现，相信你能够看懂！

Complex Complex::operator +(Complex &object)

{

Complex temp;

tempm_real=this->m_real+objectm_real ;

tempm_complex=this->m_complex+objectm_complex;

return temp;

}

Complex Complex::operator-(Complex &object)

{

Complex temp;

tempm_real=this->m_real +objectm_real ;

tempm_complex=this->m_complex +objectm_complex ;

return temp;

}

Complex Complex::operator (Complex &object)

{

Complex temp;

tempm_real=this->m_real objectm_real -this->m_complex objectm_complex ;

tempm_complex =this->m_complexobjectm_real +this->m_real objectm_complex ;

return temp;

}

Complex Complex::operator /(Complex &object)

{

Complex temp;

tempm_real =this->m_real objectm_real +this->m_complex objectm_complex ;

tempm_complex =this->m_complexobjectm_real -this->m_real objectm_complex ;

tempm_real /=objectm_real objectm_real +objectm_complex objectm_complex ;

tempm_complex/=objectm_real objectm_real +objectm_complex objectm_complex ;

return temp;

}

bool Complex::operator ==(Complex &object)

{

if(this->m_real==objectm_real &&this->m_complex ==objectm_complex )

return (cout<<" equal"<<endl,1);

if(this->m_real<objectm_real ||this->m_complex <objectm_complex )

return (cout<<" the formal is less than the last!"<<endl,0);

else

return (cout<<"the formal is biger than the last!"<<endl,0);

}

void Complex::Display ()

{

m_real==0cout<<"\n":cout<<m_real;

if(m_complex>0&&m_real)

cout<<" + ";

m_complex<=0m_complex==0cout<<"\n":cout<<m_complex<<"i"<<endl:cout<<m_complex<<"i"<<endl;

}

int main()

{

Complex object1,object2,object3,object4;

object1Setnumber ();

object2Setnumber();

object1Display();

(object1+object2)Display ();//可以不用这样的方式调用函数，但是你可以自己实现一个重载输出流函数。

object1==object2;//判断。

(object1/object2)Display ();

return 0;

}

你可以自己仔细看看！！

刚好有个我自己用的复数类，给你看看。

//double型比较误差控制

#define EPSILON 10e-7

//double型比较

inline bool E2D(double a, double b = 0)

{

return fabs(a - b) < EPSILON;

}

//复数

class Mcomplex

{

public:

double r;

double i;

Mcomplex(){}

Mcomplex(double x, double y){r = x; i = y;}

Mcomplex csqrt() const

{

double x, y, w, rr, cc;

if(E2D(r)&&E2D(i))

{

return this;

}

else

{

Mcomplex c;

x = fabs(r);

y = fabs(i);

if(x >= y)

{

rr = y / x;

cc = x;

}

else

{

rr = x / y;

cc = y;

}

w = sqrt(05 (x + cc sqrt(10 + rr rr)));

if(r >= 00)

{

cr = w;

ci = i / (20 w);

}

else

{

ci = (i >= 00) w : -w;

cr = i / (20 ci);

}

return c;

}

}

double cabs() const

{

double x,y,ans,temp;

x = fabs(this->r);

y = fabs(this->i);

if(E2D(x))

ans = y;

else if(E2D(y))

ans = x;

else if(x > y)

{

temp = y / x;

ans = x sqrt(10 + temp temp);

}

else

{

temp = x / y;

ans = y sqrt(10 + temp temp);

}

return ans;

}

Mcomplex Conjg() const

{

Mcomplex b;

br = this->r;

bi = -this->i;

return b;

}

Mcomplex operator+(const Mcomplex& dc) const

{

Mcomplex b;

br = r + dcr;

bi = i + dci;

return b;

}

Mcomplex operator-(const Mcomplex& dc) const

{

Mcomplex b;

br = r - dcr;

bi = i - dci;

return b;

}

Mcomplex operator(const Mcomplex& dc) const

{

Mcomplex b;

br = r dcr - i dci;

bi = i dcr + r dci;

return b;

}

Mcomplex operator(double x) const

{

Mcomplex dc;

dcr = x r;

dci = x i;

return dc;

}

//when dc is zero, operator / return zero

Mcomplex operator/(const Mcomplex& dc) const

{

if(E2D(dcr)&&E2D(dci))

return dc;

Mcomplex b;

if(E2D(dci))

{

br = r / dcr;

bi = i / dci;

return b;

}

if(E2D(dcr))

{

br = i / dci;

bi = -r / dci;

return b;

}

double rr, den;

if(fabs(dcr) >= fabs(dci))

{

rr = dci / dcr;

den = dcr + rr dci;

br = (this->r + rr this->i) / den;

bi = (this->i - rr this->r) / den;

}

else

{

rr = dcr / dci;

den = dci + rr dcr;

br = (this->r rr + this->i) / den;

bi = (this->i rr - this->r) / den;

}

return b;

}

Mcomplex operator -() const

{

return Mcomplex(-r,-i);

}

Mcomplex& operator=(const Mcomplex& dc)

{

r = dcr;

i = dci;

return this;

}

Mcomplex& operator -=(const Mcomplex &dc)

{

r += dcr;

i += dci;

return this;

}

Mcomplex& operator +=(const Mcomplex &dc)

{

if(&dc == this)

{

r = 00;

i = 00;

}

else

{

r -= dcr;

i -= dci;

}

return this;

}

Mcomplex& operator =(const Mcomplex &dc)

{

double oldR = r;

r = r dcr - i dci;

//必须检查自乘情况

if(&dc == this)

{

i = oldRi;

i += i;

}

else

{

i = i dcr + oldR dci;

}

return this;

}

Mcomplex& operator =(double x)

{

r = x;

i = x;

return this;

}

//when dc is zero, operator /= return zero

Mcomplex& operator /=(const Mcomplex &dc)

{

if(E2D(dcr)&&E2D(dci))

{

r = 00;

i = 00;

return this;

}

this = this / dc;

return this;

}

};

}

#include <iostream>

#include <string>

using namespace std;

string pluralize(string& singular)

{

string plural;

if (singular[singularsize()-1] == 'y') {

singular[singularsize()-1] = 'i';

plural = singular + "es";

}

else if (singular[singularsize()-1] == 's' ||

singular[singularsize()-1] == 'x' ||

(singular[singularsize()-2] == 'c' &&

singular[singularsize()-1] == 'h') ||

(singular[singularsize()-2] == 's' &&

singular[singularsize()-1] == 'h')) {

plural = singular + "es";

}

else if (singular[singularsize()-1] == 'o') {

plural = singular + "es";

}

else {

plural = singular + "s";

}

return plural;

}

int main ()

{

string word;

cin >> word;

cout << pluralize(word) << endl;

}

程序没有优化，但是功能完全，能解决你的问题！

楼上说的没办法！但是我想这个问题真的要解决恐怕几乎不可能

structcomplex{

floatrmz;//实部

floatlmz;//虚部

};

//产生一个复数

complexgetacomplex(floata,floatb){

complexnode=newcomplex();

nodermz=a;

nodelmz=b;

returnnode;}

//两个复数求和

complexaddcomplex(complexcomplex1,complexcomplex2)

{

complexnode=newcomplex();

nodermz=complex1rmz+complex2rmz;

nodelmz=complex1lmz+complex2lmz;

returnnode;

}

//求两个复数的差

complexsubcomplex(complexcomplex1,complexcomplex2)

{

complexnode=newcomplex();

nodermz=complex1rmz-complex2rmz;

nodelmz=complex1lmz-complex2lmz;

returnnode;

}

//求两个复数的积

complexproductcomplex(complexcomplex1,complexcomplex2)

{

complexnode=newcomplex();

nodermz=complex1rmzcomplex2rmz-complex1lmzcomplex2lmz;

nodelmz=complex1lmzcomplex2rmz+complex2lmzcomplex2rmz;

returnnode;

}

//求实部

floatgetcomplexrmz(complexcomplex1)

{

returncomplex1rmz;

}

//求虚部

floatgetcomplexlmz(complexcomplex1)

{

returncomplex1lmz;

}

#include <iostream> using namespace std; class Complex {public: Complex(){real=0;imag=0;} Complex(double r,double i){real=r;imag=i;} Complex operator+(Complex &c2); Complex operator-(Complex &c2); Complex operator(Complex &c2); Complex operator/(Complex &c2); void display(); private: double real; double imag; }; Complex Complex::operator+(Complex &c2) {Complex c; creal=real+c2real; cimag=imag+c2imag; return c;} Complex Complex::operator-(Complex &c2) {Complex c; creal=real-c2real; cimag=imag-c2imag; return c;} Complex Complex::operator(Complex &c2) {Complex c; creal=realc2real-imagc2imag; cimag=imagc2real+realc2imag; return c;} Complex Complex::operator/(Complex &c2) {Complex c; creal=(realc2real+imagc2imag)/(c2realc2real+c2imagc2imag); cimag=(imagc2real-realc2imag)/(c2realc2real+c2imagc2imag); return c;} void Complex::display() {cout<<"("<<real<<","<<imag<<"i)"<<endl;} int main() {Complex c1(3,4),c2(5,-10),c3; c3=c1+c2; cout<<"c1+c2="; c3display(); c3=c1-c2; cout<<"c1-c2="; c3display(); c3=c1c2; cout<<"c1c2="; c3display(); c3=c1/c2; cout<<"c1/c2="; c3display(); return 0; }

麻烦采纳，谢谢!

以上就是关于编写一个程序，可以将英语规则名词由单数变成复数全部的内容，包括:编写一个程序，可以将英语规则名词由单数变成复数、用C++编写复数计算器的程序、求C++高手做个复数类的程序等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！