精华内容
下载资源
问答
  • 复数

    2021-02-26 20:44:30
    成员函数均为公有,其中input()函数给实部和虚部赋值,output()函数按照“实部,虚部i”的格式输出复数,add()函数实现两个复数的相加。设计一个友元函数sub()实现两个复数的相减。主函数中定义若干对象,通过调用...

    复数类

    定义一个复数类Complex,复数的实部real和虚部image定义为类的私有数据成员。成员函数均为公有,其中input()函数给实部和虚部赋值,output()函数按照“实部,虚部i”的格式输出复数,add()函数实现两个复数的相加。设计一个友元函数sub()实现两个复数的相减。主函数中定义若干对象,通过调用成员函数和友元函数,完成两个复数的相加和相减。

    输入共有两行,每行两个整数,中间用空格隔开,代表两个复数。其中,前一个数是实部,后一个数是虚部。

    输出共有两行,每行按照“实部,虚部i”的格式,逗号为英文逗号,不要输出引号。第一行是相加后的复数,第二行是相减后的复数,行尾输出换行。

    输入

    2 -1
    3 1
    

    输出

    5,0i
    -1,-2i
    
    //复数类
    #include<iostream>
    #include<cmath>
    using namespace std;
    class Complex
    {
        private:
            int real;
            int image;
        public:
            void input()
            {
            	cin>>real>>image;
            }
            void output()
            {
            	cout<<real<<","<<image<<"i"<<endl;
            }
            void add(Complex,Complex);
            friend void sub(Complex,Complex,Complex *);
    };
    
    void Complex::add(Complex a,Complex b)
    {
        real=a.real+b.real;
        image=a.image+b.image;
    }
    void sub(Complex a,Complex b,Complex *c)
    {
        c->real=a.real-b.real;
        c->image=a.image-b.image;
    }
    int main(void)
    {
        Complex a1,a2,a3,a4;
        a1.input();
        a2.input();
        a3.add(a1,a2);
        sub(a1,a2,&a4);
        a3.output();
        a4.output();
        return 0;
    }
    
    展开全文
  • 紫光的一个笔试题目,求复数模的平方。和同学交流了好一会后写出如下结果 a = input("input") b =a.split("+" or "-") #按照符号分割后赋值给b def xs(b): if len(b)>1: #实部与虚部都存在 if "j" in b[0] : ...

    紫光的一个笔试题目,求复数模的平方。和同学交流了好一会后写出如下结果

    a = input("input")
    b =a.split("+" or "-")  #按照符号分割后赋值给b
    def xs(b):
        if len(b)>1:        #实部与虚部都存在
            if "j" in b[0] :
                s = int(b[0][:-1])
                x= int(b[1])
            elif "j" in b[1]:
                x = int(b[1][:-1])
                s = int(b[0])
            return s * s + x * x
        elif "j" in b[0]:   #只存在虚部
            s = int(b[0][:-1])
            return s*s
        else:               #只存在实部
            return pow(int(b[0]),2)
    print(xs(b))

    复数模的数学模型是对实部与虚部求平方后相加,再开根号如:a = 1-2j

    (1*1+(-2)*(-2))**0.5

     

    elif "j" in b[0]:   #只存在虚部
        s = int(b[0][:-1])

    这一行中使用b[0]的原因,如果只存在实部或虚部,使用s = int(b[:-1])切割["200j"]的时候获取为null.所以即使只存在实部或虚部也需要使用b[0]

    展开全文
  • 1.定义一个复数类,描述一些必须的成员函数,如:构造函数,析构函数,赋值函数,返回数据成员值的函数等。 2.定义运算符重载函数,通过重载运算符:+,-,*,/,直接实现二个复数之间的加减乘除运算。编写一个...

    实验目的:

    1.掌握用成员函数重载运算符的方法

    2.掌握用友元函数重载运算符的方法

     

    实验要求

    1.定义一个复数类,描述一些必须的成员函数,如:构造函数,析构函数,赋值函数,返回数据成员值的函数等。

    2.定义运算符重载函数,通过重载运算符:+-*/,直接实现二个复数之间的加减乘除运算。编写一个完整的程序,测试重载运算符的正确性。要求乘法“+”,“*”用友元函数实现重载,除法“-”,“/”用成员函数实现重载,参数是复数或实数。

    3.通过重载运算符:>><<=,直接实现复数的输入、输出及赋值运算,通过重载运算符:= =,!=直接实现复数的比较运算,编写一个完整的程序,测试重载运算符的正确性。

     

    操作菜单可参考如下格式:

    1输入复数

    2查看输入的复数

    3复数相加

    4复数相减

    5复数相乘

    6复数相除

    7输出结果

    0退出

     

    #include <iostream>
    #include<cstdio>
    using namespace std;
    class Complex
    {
    public:
        Complex(double r = 0,double i = 0)//构造函数
        {
            real=r;
            imag=i;
        }
        ~Complex()
        {
    
        }
        friend Complex operator+(Complex &c1,Complex &c2);   //重载为友员函数
        friend Complex operator*(Complex &c1,Complex &c2);
        Complex operator -(Complex&);//重载为成员函数
        Complex operator /(Complex&);
        friend istream& operator>>(istream&, Complex&);
        friend ostream& operator<<(ostream&, Complex&);
        friend bool operator==(Complex &c1,Complex &c2);
        friend bool operator!=(Complex &c1,Complex &c2);
        void display( );
    private:
        double real;
        double imag;
    };
    Complex operator + (Complex &c1,Complex &c2)
    {
        return Complex(c1.real+c2.real, c1.imag+c2.imag);
    }
    Complex operator * (Complex &c1,Complex &c2)
    {
        return Complex(c1.real*c2.real, c1.imag*c2.imag);
    }
    Complex Complex::operator-(Complex &c)
    {
        return Complex(real-c.real,imag-c.imag);
    }
    Complex Complex::operator/(Complex &c)
    {
        return Complex(real/c.real,imag/c.imag);
    }
    
    istream& operator>>( istream& in, Complex &c )
    {
        in >> c.real >> c.imag;
        return in;
    }
    ostream& operator<<( ostream& out, Complex &c )
    {
        out << c.real << "+" << c.imag << "i\n";
        return  out;
    }
    
    bool operator == (Complex &c1,Complex &c2)
    {
        if(c1.real==c2.real&&c1.imag==c2.imag)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    bool operator != (Complex &c1,Complex &c2)
    {
        if(c1.real!=c2.real||c1.imag!=c2.imag)
        {
            return true;
        }
        else
        {
            return false;
        }
    }
    void Complex::display( )
    {
        cout<<real<< "+" <<imag<<"i\n"<<endl;
    }
    int Menu()
    {
        int t;
        cout << endl;
        cout<<"=================="<<endl;
        cout<<"1.输入复数"<<endl;
        cout<<"2.查看输入的复数"<<endl;
        cout<<"3.复数相加"<<endl;
        cout<<"4.复数相减"<<endl;
        cout<<"5.复数相乘"<<endl;
        cout<<"6.复数相除"<<endl;
        cout<<"7.输出结果"<<endl;
        cout<<"0.退出"<<endl;
        cout<<"=================="<<endl;
        cout<<"请选择(0-7):";
        cin>>t;
        return t;
    }
    
    int main()
    {
        int iChoice =1;
        Complex c1,c2,c3,c4;
        while (iChoice!=0)
        {
            iChoice = Menu();
            switch (iChoice)
            {
            case 1:
            {
                cout<<"请输入一个复数:"<<endl;
                cin>>c1;
                getchar();
                break;
            }
            case 2:
            {
                //c1.display();
                cout<<c1;
                break;
            }
            case 3:
            {
                cout<<"原有的复数:"<<endl;
                cout<<c1;
                cout<<"请再输入一个复数相加:"<<endl;
                cin>>c2;
                getchar();
                c3=c1+c2;
                break;
            }
            case 4:
            {
                cout<<"原有的复数:"<<endl;
                cout<<c1;
                cout<<"请再输入一个复数相减:"<<endl;
                cin>>c2;
                getchar();
                c3=c1-c2;
                break;
            }
            case 5:
            {
                cout<<"原有的复数:"<<endl;
                cout<<c1;
                cout<<"请再输入一个复数相乘:"<<endl;
                cin>>c2;
                getchar();
                c3=c1*c2;
                break;
    
            }
            case 6:
            {
                cout<<"原有的复数:"<<endl;
                cout<<c1;
                cout<<"请再输入一个复数相除:"<<endl;
                cin>>c2;
                getchar();
                c3=c1/c2;
                break;
            }
            case 7:
            {
                cout<<"运算的结果:"<<endl;
                cout<<c3;
                break;
            }
            case 0:
            {
                break;
    
            }
            }
        }
    
    
        return 0;
    }

     

    转载于:https://www.cnblogs.com/wkfvawl/p/10645134.html

    展开全文
  • 比如在定义一个复数类Complex的时候,如果不写复制构造函数的话,可以直接一个值赋予对象。如:Complex c=4.5可以完成。但是一旦写了复制构造函数,就会出现错误:[Error] no matching function for call to '...
  • User defined literal是c++提供的特性,可以让编程者仅常规的几个数据类型来初始化自定义的类对象,而不需要显式调用类构造/...首先构建一个简单的复数类模板,只实现读取/赋值实部虚部的接口:template &lt...

    User defined literal是c++提供的特性,可以让编程者仅用常规的几个数据类型来初始化自定义的类对象,而不需要显式调用类构造/拷贝方法,使代码可读性更高。但实际上这本质上还是是运算符的重载,还是要调用一部分方法。下文记录了尝试该特性的实验,这个小实验以构建一个复数类为契机,简单了解一下udl特性。

    首先构建一个简单的复数类模板,只实现读取/赋值实部虚部的接口:

    template <typename T> class ComplexBase {
    public:
    	ComplexBase() = default;
    
    	T re() const {return x;}
    	T& re() {return x;}
    	T im() const {return y;}
    	T& im() {return y;}
    
    protected:
    	T x;
    	T y;
    };

    对该类派生出一个实虚部都是整数类型的虚数类以及相应的重载方法:

    class ComplexInt : public ComplexBase<int> {
    public:
    	ComplexInt() = default; // explicit declaration, avoid being ambiguous
    	ComplexInt(int i, int j) { x = i; y = j; }
    
    	/* Leave copy and = to default */
    
    	ComplexInt(int i) { x = i; y = 0;} // converting constructor
    
    	inline friend std::ostream& operator<< (std::ostream& os, ComplexInt c) {
    		os << c.re() << " + " << c.im() << "i";
    		return os;
    	}
    };
    
    inline ComplexInt operator+ (const ComplexInt c1, const ComplexInt c2) {
    	ComplexInt c;
    	c.re() = c1.re() + c2.re();
    	c.im() = c1.im() + c2.im();
    	return c;
    }
    
    inline ComplexInt operator- (const ComplexInt c1, const ComplexInt c2) {
    	ComplexInt c;
    	c.re() = c1.re() - c2.re();
    	c.im() = c1.im() - c2.im();
    	return c;
    }
    
    inline ComplexInt operator* (const ComplexInt c1, const ComplexInt c2) {
    	ComplexInt c;
    	c.re() = c1.re() * c2.re() - c1.im() * c2.im();
    	c.im() = c1.re() * c2.im() + c1.im() * c2.re();
    	return c;
    }

    到此为止一个可以使用的复数类就实现了,在主函数里可以这样调用:

    int main() {
    
    	ComplexInt c1(1, 1), c2(1, -1);
    	cout << c1 + c2 << endl;
    	cout << c1 * c2 << endl;
    }

    但是诸如c(x, y)这样的初始化方法还是太不直观了,用户希望使用c = x + y_i这样的形式来构建简单的复数对象。

    literal运算符或者说operator "",和其他类型的运算符一样,可以重载亦可模板化,甚至可以作为类的友元,其形式为

    template <T1> T2 operator "" _x();

    注意!literal重载不能写在类声明内,必须置于外部。如果放在类声明内,报错:

    error: literal operator 'operator""_i' must be in a namespace or global scope
            ComplexInt operator"" _i (int j) {return ComplexInt(0, j);}

    其中T1只能是常用类型中的unsigned long long, long double, char, const char*这几个类型,当然还有其他类型但不常用,就不列出了。在这个复数类例子中,重载为:

    ComplexInt operator"" _i (unsigned long long j) {return ComplexInt(0, j);}

    该重载将一个代下表的整数转换成一个ComplexInt类的纯虚数。

    通过原本就实现的类型转换,可以实现将一个整数转换成ComplexInt类的纯实数。于是可以在主函数里调用:

    int main() {
    
    	ComplexInt c1 = 1 + 1_i, c2 = 1 - 1_i;
    	cout << c1 + c2 << endl;
    	cout << c1 - c2 + 1 << endl;
    	cout << c1 * c2 << endl;
    	cout << c1 * c2 - 2_i << endl;
    }

    输出:

    2 + 0i
    1 + 2i
    2 + 0i
    2 + -2i
    如有错误请指正,我什么都会做的
    展开全文
  • public class plural { public static void main(String[] args) { int a=2; int b=3; for (int i = 1; i <... //一开始a赋值会使后面的b数据出错 b=3*a+2*b; a=temp;...
  • 布尔值主要是在进行逻辑判断的时候产生,其对应的整数值可以用于统计计数时:a=3b=3a==b#返回True在这里a和b都被赋值为整数3,第三行代码是判断a和b是否相等,所以最后返回的是True.关于'='和'=='...
  • 数值类型(整型、浮点型、复数型)、布尔型、字符串、列表、元组、字典和集合等2.Python语言有哪些运算符?请列表说明它们各自的运算优先级。算术运算符、位运算符、关系运算符、逻辑运算符、赋值运算符、成员运算符、...
  • 文章目录前言Python基础注释变量数据类型浮点型复数类型字符串布尔类型类型转换输入与输出运算符算术运算符比较运算符赋值运算符逻辑运算符if、while、for容器列表元组字典集合函数函数的定义缺省参数命名参数不定长...
  • React(16)包裹标签 React.Fragment

    万次阅读 2018-02-12 18:20:58
    在 Vue 里,我们会 &lt;template&gt;&lt;/template&gt; 标签来包裹一些不能有父容器的复数同级标签。 例如在 &lt;tbody&gt;&lt;/tbody&gt; 标签中,我们只能放置 &lt;tr&...
  • 用到的Python运算符

    2019-09-30 12:25:22
    j或者J表示复数 complex(re, im) 将参数转化为复数,re为复数的实部,Im为复数的虚部。im 默认为0   假设变量a为10,变量b为20。 算术运算符 比较运算符 赋值运算符 逻辑运算符 ...
  • 在main函数中,输入两个复数,判断两个复数是否相等(实部和虚部要分别相等),然后两者相加之和赋值给一个新的复数,并输出 思考:基于上面的Complex类,有如下main函数能否通过运行,有那些是错误的,为什么? int...
  • 说明: Complex 是个复数类,我在傅里叶变换的时候用到它 1:使用中要包含#include 2:complex 赋值的几种方式:  2.1 在初始化的时候赋值 如: complex c(3.2,-6);   2.2 构造无名对象赋值方式 如: c =...
  • python学习笔记一

    2018-09-22 21:51:00
    源自南京大学——Python玩转数据: python中的运算符: python中的赋值: 链式赋值: 多重赋值: 关于python中元组的补充: http://www.runoob.com/python/python-tuples.html python中的数据...
  • Python学习之变量

    2017-11-23 21:07:00
    Python 变量 ...“=”赋值,左边是变量名,右边是变量的值 数字 整数 int_var =1 长整数 long_var =1000L 浮点数 float_var =1.0 复数 这个不讲了,的不多。需...
  • R的入门学习

    2016-08-31 15:02:03
    初学R,进行知识总结: ...赋值语句:x 数值型直接数字,整数型在数字后加L,字符串“”括起来,逻辑的TRUE和FALSE都大写。Class(x)来查看x的类型。 向量和数组可以包含多个元素,但必须是同一类型
  • = 赋值 变量名 = 值 定义变量名时不需要指定类型,解释器会根据等号右侧的数据自动推导出类型 变量类型 数字型和非数字型 数字型 整型 浮点型 布尔型(非0即真) 复数型 非数字型 字符串 列表 元组 字典 ...
  • 数据类型

    2021-02-19 11:06:52
    数据类型内置的 type() 函数可以用来查询变量所指的对象类型。 Python 中的变量不需要声明。变量在使用前需要赋值。在 Python 中,变量没有类型。...如果赋值是字符串单引号 ’ 或双引号 " 括起来,同时使用反斜杠
  • type()和isinstance()查看变量的数据类型 可同时为多个变量赋值 在变量赋值时 Number 对象将被创建、使用del语句删除一些数字对象的引用 数字运算 除法 / 总是返回一个浮点数 // 与分母分子的数据类型...
  • Task 04 单元元组

    2019-10-23 21:27:22
    包括:单元元组、实数矩阵、文本字符串数组、结构 数组以及其他复数向量等 创建:对单元元组赋值 C=cell(n) #建立n阶单元空方阵 C=cell(m,n) #建立m行n列单元空方阵 C=cell(size(A)) #建立与矩形A同维的空单元矩...
  • python变量

    2019-09-26 01:31:14
    “=”赋值,左边是变量名,右边是变量的值 数字 整数 int_var = 1 长整数 long_var = 1000L 浮点数 float_var = 1.0 复数 这个不讲了,的不多。需要的时候自行查资料吧 字符串 #!/usr/bin/pyt...
  • 实验报告 课程名称C#程序设计 实验地点 班级 学号 姓名 一实验名称 多态 二实验目的 通过本章学习理解多态的概念掌握多态实现方式掌握...默认构造函数将实部和虚部初始化为0 重载构造函数为实例化对象时给对象赋值 ne
  • 对象赋值实际上是对象的引用变量的命名:变量名由字母,数字,下划线组成,注意:不可以以数字开头python中,变量定义时不需要指定类型的,当变量的时候,必须要给这个变量赋值给a赋值为100,然后打印 二....
  • Python的基础语法巩固

    2020-09-29 14:37:31
    python中,变量定义时不需要指定类型的,当变量的时候,必须要给这个变量赋值 给a赋值为100,然后打印 二. 认识运算符 数字的类型: int 整数 long 长整数 bool 布尔值 float 浮点型 complex 复数 ...
  • = 赋值,左边是变量名,右边是变量的值 Integral类型 整型: 不可变类型 布尔型 浮点类型 十进制数字 复数 字符串 所有字符串必须加引号 列表 类似数组 一个有序可变集合的容器 列表支持...
  • R的数据类型

    2019-06-06 23:22:00
    数据结构 对象的5钟基本类型 1,字符 2,数值 3,整数 4,复数 ...正常的赋值一般默认为numeric数据类型,如果想赋值为整数类型,可以在值后面加上L例如...R中赋值逻辑字符,都需要大写字母例如 t <- TRUE ...
  • “=”赋值,左边是变量名,右边是变量的值1.1、 数字整数int_var = 1长整数long_var = 1000L浮点数float_var = 1.0复数这个不讲了,的不多。需要的时候自行查资料吧1.2、 字符串运行以上代码的结果:1.3、列表 ...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 150
精华内容 60
关键字:

复数用赋值