是"；“复数”；已经在Objective-C中定义了吗？

对于以下代码

-Objective-C如何知道在复数中添加“i”？当我在Complex.m文件中将“real”和“virtual”定义为双值时，我认为Xcode只知道“real”和“virtual”是双值

-如果我在main.m文件中的复数末尾添加一个“I”，例如，如果我将“myComplex.virginal=7；”转换为“myComplex.virginal=7i；”，该行的输出将变为0.00000i，如果我添加任何其他字母，程序将无法运行，这是为什么

基本上，我觉得Xcode已经知道“真实”和“想象”的含义，我下面的书没有具体说明这一点，所以我有点困惑

另外，我应该注意，我没有创建以下代码，因为我自己无法解决问题，这些代码是从我的图书论坛的一个成员那里复制的

//  Complex.h

#include <Foundation/Foundation.h>

@interface Complex : NSObject
@property double real, imaginary;
-(void) print;
-(Complex *) add: (Complex *) complexNum;
-(Complex *) subtract: (Complex *) complexNum;
-(Complex *) multiply: (Complex *) complexNum;
-(Complex *) divide: (Complex *) complexNum;
@end

//  Complex.m

#import "Complex.h"

@implementation Complex
@synthesize real, imaginary;

-(void) print
{
    NSLog(@"%f + %fi", real, imaginary);
}
-(Complex *) add: (Complex *) complexNum
{
    Complex *result = [[Complex alloc]init];
    result.real = real + complexNum.real;
    result.imaginary = imaginary + complexNum.imaginary;
    return result;
}
-(Complex *) subtract: (Complex *) complexNum
{
    Complex *result = [[Complex alloc]init];
    result.real = real - complexNum.real;
    result.imaginary = imaginary - complexNum.imaginary;
    return result;
}
-(Complex *) multiply: (Complex *) complexNum
{
    Complex *result = [[Complex alloc]init];
    result.real = real * complexNum.real;
    result.imaginary = imaginary * complexNum.imaginary;
    return result;
}
-(Complex *) divide: (Complex *) complexNum
{
    Complex *result = [[Complex alloc]init];
    result.real = real / complexNum.real;
    result.imaginary = imaginary / complexNum.imaginary;
    return result;
}
@end

//
//  main.m
//  Complex

#include <Foundation/Foundation.h>
#import "Complex.h"

int main(int argc, const char *argv[]) {

    @autoreleasepool {
        Complex *myComplex = [[Complex alloc]init];
        Complex *totalComplex = [[Complex alloc]init];
        Complex *yourComplex = [[Complex alloc]init];

        myComplex.real = 5.3;
        myComplex.imaginary = 7;
        [myComplex print];
        NSLog(@"+");

        yourComplex.real = 2.7;
        yourComplex.imaginary = 4;
        [yourComplex print];
        NSLog(@"=");

        totalComplex = [myComplex add: yourComplex];
        [totalComplex print];
    }
    return 0;
}

//Complex.h
#包括
@接口复合体：NSObject
@双重不动产、假想财产；
-（作废）打印；
-（Complex*）添加：（Complex*）complexNum；
-（复数*）减法：（复数*）复数num；
-（复数*）乘法：（复数*）复数num；
-（复数*）除：（复数*）复数；
@结束
//复杂的
#导入“Complex.h”
@实施复合体
@综合真实、想象；
-（作废）打印
{
NSLog（@“%f+%fi”，实的，虚的）；
}
-（复杂*）添加：（复杂*）复杂数
{
复杂*result=[[Complex alloc]init]；
result.real=real+complexNum.real；
result.virtual=virtual+complexNum.virtual；
返回结果；
}
-（复数*）减法：（复数*）复数num
{
复杂*result=[[Complex alloc]init]；
result.real=real-complexNum.real；
result.virtual=virtual-complexNum.virtual；
返回结果；
}
-（复数*）乘法：（复数*）复数num
{
复杂*result=[[Complex alloc]init]；
result.real=real*complexNum.real；
result.virtual=virtual*complexNum.virtual；
返回结果；
}
-（复数*）除：（复数*）复数数
{
复杂*result=[[Complex alloc]init]；
result.real=real/complexNum.real；
result.virtual=virtual/complexNum.virtual；
返回结果；
}
@结束
//
//main.m
//复杂的
#包括
#导入“Complex.h”
int main（int argc，const char*argv[]{
@自动释放池{
Complex*myComplex=[[Complex alloc]init]；
Complex*totalComplex=[[Complex alloc]init]；
Complex*yourComplex=[[Complex alloc]init]；
myComplex.real=5.3；
myComplex.virtual=7；
[myComplex打印]；
NSLog（@“+”）；
yourComplex.real=2.7；
yourComplex.virtual=4；
[yourComplex print]；
NSLog（@“=”）；
totalComplex=[myComplex添加：yourComplex]；
[totalComplex print]；
}
返回0；
}

中定义了复数类型，现代版本的Objective-C是其超集：

• 如果我将“myComplex.virginal=7；”转换为“myComplex.virginal=7i；”，该行的输出将变为0.00000i

因为7i是一个虚数，

myComplex.virginal

是一个“double”，因此是实数。C标准建议，在实数和虚数之间转换时，将得到零（C99§G.4.2/1）。因此，实际上你写的是

myComplex.virtual=0.0


如果我添加任何其他字母，程序将无法运行，这是为什么

实际上，你可以编写类似于
7.0if
的东西。同样，这是一个C的东西，Objective-C已经适应了它。您可以添加一个
f
将十进制数从默认类型“double”转换为“float”，GCC还添加了一个额外功能，您可以添加一个
i
将实数转换为虚数。其他的满足条件，如
7.0x
，将导致编译器停止，因为它不知道
x
的含义。
C99增加了对复数的本机支持，因此现在它们与普通浮点数或整数一样易于处理。不再有丑陋的结构！大概是通过对数字的浮点表示进行操作，
\u Complex\u I
和等效的
I
宏具有一个值，当与实数相乘时，会产生一个类型为
双复数
或
浮点复数
（
complex
是一个新的类型修饰符关键字，也在C99中引入）。因此，通过这个新的方便功能，您可以尽可能轻松地在C中执行复数计算

#include <complex.h>

double complex z1 = 2.0 + 3.0 * I;
double complex z2 = 1.5 - 2.0 * I;
double complex prod = z1 * z2;

printf("Product = %f + %f\n", creal(prod), cimag(prod));

#包括
双复数z1=2.0+3.0*I；
双络合物z2=1.5-2.0*I；
双复prod=z1*z2；
printf（“产品=%f+%f\n”、creal（prod）、cimag（prod））；

请检查一下这个

i
后缀是C99语言的GNU扩展，因此它是非标准的。然而，Xcode（GCC和Clang）使用的两个编译器都实现了这个扩展

（旁注：Xcode对此一无所知。请不要将IDE与编译器混淆。Xcode本身不执行编译—它背后的编译器执行编译。）
在类复数实现中有两个严重错误-复数的乘法和除法是绝对错误的！仅仅将两个复数的实部和虚部相乘或除法是绝对不够的。你必须使用乘法和除法公式。在这种情况下，我认为谷歌包含了很多条目现在它是错误的代码，必须重写

对于乘法，它一定是这样的

-(Complex *)mul:(Complex *)n
{
    Complex *res = [[Complex alloc]init];
    res.re = re * n.re - im * n.im;
    res.im = re * n.im + im * n.re;
    return res;
}

这是我为我的项目开发的一个用于处理复数的类。它可能对某些人有用。它包含标准的加法、减法、乘法和除法。此外，它还有计算复数的模和参数的方法。最后，它还有计算复数的类方法
#include <complex.h>

double complex z1 = 2.0 + 3.0 * I;
double complex z2 = 1.5 - 2.0 * I;
double complex prod = z1 * z2;

printf("Product = %f + %f\n", creal(prod), cimag(prod));

-(Complex *)mul:(Complex *)n
{
    Complex *res = [[Complex alloc]init];
    res.re = re * n.re - im * n.im;
    res.im = re * n.im + im * n.re;
    return res;
}

#import <Foundation/Foundation.h>

@interface Complex : NSObject
@property double re, im;
-(Complex *)add :(Complex *) n;
-(Complex *)sub :(Complex *) n;
-(Complex *)mul :(Complex *) n;
-(Complex *)div :(Complex *) n;
+(Complex *)wkn :(int) k :(int) n;
-(double)mod;
-(double)arg;
@end

#import "Complex.h"

@implementation Complex
@synthesize re, im;
// Addition of two complex numbers
-(Complex *)add:(Complex *)n
{
    Complex *res = [[Complex alloc]init];
    res.re = re + n.re;
    res.im = im + n.im;
    return res;
}
// Subtraction of two complex numbers
-(Complex *)sub:(Complex *)n
{
    Complex *res = [[Complex alloc]init];
    res.re = re - n.re;
    res.im = im - n.im;
    return res;
}
// Multiplication of two complex numbers
-(Complex *)mul:(Complex *)n
{
    Complex *res = [[Complex alloc]init];
    res.re = re * n.re - im * n.im;
    res.im = re * n.im + im * n.re;
    return res;
}
// Division of two complex numbers
-(Complex *)div: (Complex *)n
{
    Complex *res = [[Complex alloc]init];
    double A = (pow(n.re, 2.0) + pow(n.im, 2.0));
    res.re = (re * n.re - im * n.im) / A;
    res.im = (im * n.re - re * n.im) / A;
    return res;
}
// Modulus of complex number
-(double)mod
{
    double res = sqrt(pow(re, 2.0) + pow(im, 2.0));
    return res;
}
// Argument of complex number
-(double)arg
{
    double res; int quad;
    if (re == 0 && im > 0) res = M_PI_2;
    else if (re == 0 && im < 0) res = 3 * M_PI_2;
    else
    {
        if (re > 0 && im >= 0) quad = 1;
        else if (re < 0 && im >= 0) quad = 2;
        else if (re < 0 && im < 0) quad = 3;
        else if (re > 0 && im < 0) quad = 4;
        double temp = atan(im / re);
        switch (quad)
        {
            case 1:
                res = temp;
                break;
            case 4:
                res = 2 * M_PI + temp;
                break;
            case 2: case 3:
                res = M_PI + temp;
                break;
        }
    }
    return res;
}
// Turning factor calculation for "butterfly" FFT algorithm
+(Complex *)wkn:(int)k :(int)n
{
    Complex *res = [[Complex alloc]init];
    res.re = cos(2 * M_PI * k / n);
    res.im = -sin(2 * M_PI * k / n);
    return res;
}

@end