c# 直接使用 c++ 写的 class

Question

c++ 完整类 写法如下，开发环境使用 vs2010 ，建立的类库工程 动态 dll 方式
如何在 c# 中使用这个类，并且能使用其中 构造函数，和方法，直接使用，请给我具体代码 ，和改写c++的代码，

c++代码如下

//复数运算类.h
  #include  <iostream>
  #include  <cmath>
  using namespace std;
  class  complex
  {
  private: 
           double  R;
           double  I;
  public:
           complex (double real=0, double imag=0)    //构造函数
           { R = real;  I = imag;  }
           void prt ()                             //复数输出
           { 
               cout <<"(" <<R <<", " <<I <<")" ; 
                                        //输出形式为:(实部, 虚部)
               return;
           }
           double cfabs()                         //复数模
           {
               double y;
               y=sqrt(R*R+I*I);
               return y;
           }
           double angle()                        //复数幅角
           {
               double y;
               y = atan2(I, R);
               return(y);
           }
           complex operator + (complex& c2)         //复数加法
           {
               complex c;
               c.R = R + c2.R;  c.I = I + c2.I; 
               return c;
           }
           complex operator - (complex& c2)         //复数减法
           {
               complex c;
               c.R = R - c2.R;  c.I = I - c2.I; 
               return c;
           }
           complex operator * (complex& c2)          //复数乘法
           {
               complex c;
               double p, q, s;
               p = R*c2.R; q = I*c2.I;
               s = (R+I)*(c2.R+c2.I);
               c.R = p - q;  c.I = s - p - q;
               return c;
           }
           complex operator / (complex& c2)           //复数除法
           {
               complex c;
               double p, q, s, w;
               p = R*c2.R; q = - I*c2.I;
               s = (R+I)*(c2.R-c2.I);
               w = (c2.R)*(c2.R) + (c2.I)*(c2.I);
               if (w + 1.0 != 1.0)
               {
                   c.R = (p - q)/w;  c.I = (s - p - q)/w;
               }
               else
               {
                   c.R =1e+300 ;  c.I =1e+300 ;
               }
               return c;
           }
           complex cpower (int n)              //复数乘幂
           {
               complex  c;
               double r, q;
               q = atan2(I, R);
               r = sqrt(R*R + I*I);
               if (r+1.0 != 1.0)
               { r = n*log(r);  r = exp(r); }
               c.R = r*cos(n*q);  c.I = r*sin(n*q);
               return  c;
           }
           void croot (int n, complex *p)                 //复数的n次方根
           {
               complex c;
               int k;
               double r, q, t;
               if (n < 1) return;
               q = atan2(I, R);
               r = sqrt(R*R + I*I);
               if (r+1.0 != 1.0)
               { r = (1.0/n)*log(r);  r = exp(r); }
               for (k=0; k<n; k++)
               {
                   t = (2.0*k*3.1415926 + q)/n;
                   c.R = r*cos(t);  c.I = r*sin(t);
                   p[k] = c;
               }
           }
           complex cexp ()                      //复数指数
           {
               complex c;
               double p;
               p = exp(R);
               c.R = p*cos(I);  c.I = p*sin(I);
               return c;
           }
           complex clog ()                       //复数对数
           {
               complex c;
               double p;
               p = R*R + I*I;
               p = log(sqrt(p));
               c.R = p;  c.I = atan2(I, R);
               return c;
           }
           complex csin ()                       //复数正弦
           {
               complex c;
               double p, q;
               p = exp(I); q = exp(-I);
               c.R = sin(R)*(p+q)/2;
               c.I = cos(R)*(p-q)/2;
               return c;
           }
           complex ccos()                       //复数余弦
           {
               complex c;
               double p, q;
               p = exp(I); q = exp(-I);
               c.R = cos(R)*(p+q)/2;
               c.I = -sin(R)*(p-q)/2;
               return c;
           }
  };

Answer 1

该回答引用自GPT-3.5, 由博主 GISer Liu 编写：

好的，下面我将详细解答如何在C#中使用C++编写的类，并且能使用其中的构造函数和方法。

1. 修改C++代码以支持C#调用

首先，我们需要对C++代码进行一些修改，以便通过P/Invoke（平台调用）在C#中使用。我们需要将类的方法和构造函数导出为DLL中的函数。

修改后的C++代码

// 复数运算类.h
#include <iostream>
#include <cmath>
using namespace std;

extern "C" {
    __declspec(dllexport) void* complex_create(double real, double imag);
    __declspec(dllexport) void complex_destroy(void* ptr);
    __declspec(dllexport) void complex_prt(void* ptr);
    __declspec(dllexport) double complex_cfabs(void* ptr);
    __declspec(dllexport) double complex_angle(void* ptr);
    __declspec(dllexport) void* complex_add(void* ptr, void* ptr2);
    __declspec(dllexport) void* complex_sub(void* ptr, void* ptr2);
    __declspec(dllexport) void* complex_mul(void* ptr, void* ptr2);
    __declspec(dllexport) void* complex_div(void* ptr, void* ptr2);
    __declspec(dllexport) void* complex_cpower(void* ptr, int n);
    __declspec(dllexport) void complex_croot(void* ptr, int n, void** p);
    __declspec(dllexport) void* complex_cexp(void* ptr);
    __declspec(dllexport) void* complex_clog(void* ptr);
    __declspec(dllexport) void* complex_csin(void* ptr);
    __declspec(dllexport) void* complex_ccos(void* ptr);
}

class complex {
private:
    double R;
    double I;
public:
    complex(double real = 0, double imag = 0) { R = real; I = imag; }
    void prt() {
        cout << "(" << R << ", " << I << ")";
        return;
    }
    double cfabs() {
        double y;
        y = sqrt(R * R + I * I);
        return y;
    }
    double angle() {
        double y;
        y = atan2(I, R);
        return (y);
    }
    complex operator + (complex& c2) {
        complex c;
        c.R = R + c2.R; c.I = I + c2.I;
        return c;
    }
    complex operator - (complex& c2) {
        complex c;
        c.R = R - c2.R; c.I = I - c2.I;
        return c;
    }
    complex operator * (complex& c2) {
        complex c;
        double p, q, s;
        p = R * c2.R; q = I * c2.I;
        s = (R + I) * (c2.R + c2.I);
        c.R = p - q; c.I = s - p - q;
        return c;
    }
    complex operator / (complex& c2) {
        complex c;
        double p, q, s, w;
        p = R * c2.R; q = -I * c2.I;
        s = (R + I) * (c2.R - c2.I);
        w = (c2.R) * (c2.R) + (c2.I) * (c2.I);
        if (w + 1.0 != 1.0) {
            c.R = (p - q) / w; c.I = (s - p - q) / w;
        }
        else {
            c.R = 1e+300; c.I = 1e+300;
        }
        return c;
    }
    complex cpower(int n) {
        complex c;
        double r, q;
        q = atan2(I, R);
        r = sqrt(R * R + I * I);
        if (r + 1.0 != 1.0) { r = n * log(r); r = exp(r); }
        c.R = r * cos(n * q); c.I = r * sin(n * q);
        return c;
    }
    void croot(int n, complex* p) {
        complex c;
        int k;
        double r, q, t;
        if (n < 1) return;
        q = atan2(I, R);
        r = sqrt(R * R + I * I);
        if (r + 1.0 != 1.0) { r = (1.0 / n) * log(r); r = exp(r); }
        for (k = 0; k < n; k++) {
            t = (2.0 * k * 3.1415926 + q) / n;
            c.R = r * cos(t); c.I = r * sin(t);
            p[k] = c;
        }
    }
    complex cexp() {
        complex c;
        double p;
        p = exp(R);
        c.R = p * cos(I); c.I = p * sin(I);
        return c;
    }
    complex clog() {
        complex c;
        double p;
        p = R * R + I * I;
        p = log(sqrt(p));
        c.R = p; c.I = atan2(I, R);
        return c;
    }
    complex csin() {
        complex c;
        double p, q;
        p = exp(I); q = exp(-I);
        c.R = sin(R) * (p + q) / 2;
        c.I = cos(R) * (p - q) / 2;
        return c;
    }
    complex ccos() {
        complex c;
        double p, q;
        p = exp(I); q = exp(-I);
        c.R = cos(R) * (p + q) / 2;
        c.I = -sin(R) * (p - q) / 2;
        return c;
    }
};

void* complex_create(double real, double imag) {
    return new complex(real, imag);
}

void complex_destroy(void* ptr) {
    delete static_cast<complex*>(ptr);
}

void complex_prt(void* ptr) {
    static_cast<complex*>(ptr)->prt();
}

double complex_cfabs(void* ptr) {
    return static_cast<complex*>(ptr)->cfabs();
}

double complex_angle(void* ptr) {
    return static_cast<complex*>(ptr)->angle();
}

void* complex_add(void* ptr, void* ptr2) {
    complex* c1 = static_cast<complex*>(ptr);
    complex* c2 = static_cast<complex*>(ptr2);
    return new complex(*c1 + *c2);
}

void* complex_sub(void* ptr, void* ptr2) {
    complex* c1 = static_cast<complex*>(ptr);
    complex* c2 = static_cast<complex*>(ptr2);
    return new complex(*c1 - *c2);
}

void* complex_mul(void* ptr, void* ptr2) {
    complex* c1 = static_cast<complex*>(ptr);
    complex* c2 = static_cast<complex*>(ptr2);
    return new complex(*c1 * *c2);
}

void* complex_div(void* ptr, void* ptr2) {
    complex* c1 = static_cast<complex*>(ptr);
    complex* c2 = static_cast<complex*>(ptr2);
    return new complex(*c1 / *c2);
}

void* complex_cpower(void* ptr, int n) {
    return new complex(static_cast<complex*>(ptr)->cpower(n));
}

void complex_croot(void* ptr, int n, void** p) {
    complex* c = static_cast<complex*>(ptr);
    complex* roots = new complex[n];
    c->croot(n, roots);
    for (int i = 0; i < n; i++) {
        p[i] = new complex(roots[i]);
    }
    delete[] roots;
}

void* complex_cexp(void* ptr) {
    return new complex(static_cast<complex*>(ptr)->cexp());
}

void* complex_clog(void* ptr) {
    return new complex(static_cast<complex*>(ptr)->clog());
}

void* complex_csin(void* ptr) {
    return new complex(static_cast<complex*>(ptr)->csin());
}

void* complex_ccos(void* ptr) {
    return new complex(static_cast<complex*>(ptr)->ccos());
}

2. 在C#中使用C++类

接下来，我们需要在C#中通过P/Invoke调用这些导出的函数。

C#代码

using System;
using System.Runtime.InteropServices;

class Program
{
    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_create(double real, double imag);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void complex_destroy(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void complex_prt(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double complex_cfabs(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern double complex_angle(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_add(IntPtr ptr, IntPtr ptr2);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_sub(IntPtr ptr, IntPtr ptr2);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_mul(IntPtr ptr, IntPtr ptr2);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_div(IntPtr ptr, IntPtr ptr2);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_cpower(IntPtr ptr, int n);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern void complex_croot(IntPtr ptr, int n, IntPtr[] p);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_cexp(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_clog(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_csin(IntPtr ptr);

    [DllImport("YourDllName.dll", CallingConvention = CallingConvention.Cdecl)]
    public static extern IntPtr complex_ccos(IntPtr ptr);

    static void Main(string[] args)
    {
        IntPtr c1 = complex_create(1.0, 2.0);
        IntPtr c2 = complex_create(3.0, 4.0);

        complex_prt(c1);
        Console.WriteLine();
        complex_prt(c2);
        Console.WriteLine();

        double abs1 = complex_cfabs(c1);
        double angle1 = complex_angle(c1);
        Console.WriteLine($"Abs: {abs1}, Angle: {angle1}");

        IntPtr sum = complex_add(c1, c2);
        complex_prt(sum);
        Console.WriteLine();

        IntPtr diff = complex_sub(c1, c2);
        complex_prt(diff);
        Console.WriteLine();

        IntPtr prod = complex_mul(c1, c2);
        complex_prt(prod);
        Console.WriteLine();

        IntPtr quot = complex_div(c1, c2);
        complex_prt(quot);
        Console.WriteLine();

        IntPtr power = complex_cpower(c1, 2);
        complex_prt(power);
        Console.WriteLine();

        const int n = 3;
        IntPtr[] roots = new IntPtr[n];
        complex_croot(c1, n, roots);
        for (int i = 0; i < n; i++) {
            complex_prt(roots[i]);
            Console.WriteLine();
        }

        IntPtr exp = complex_cexp(c1);
        complex_prt(exp);
        Console.WriteLine();

        IntPtr log = complex_clog(c1);
        complex_prt(log);
        Console.WriteLine();

        IntPtr sin = complex_csin(c1);
        complex_prt(sin);
        Console.WriteLine();

        IntPtr cos = complex_ccos(c1);
        complex_prt(cos);
        Console.WriteLine();

        complex_destroy(c1);
        complex_destroy(c2);
        complex_destroy(sum);
        complex_destroy(diff);
        complex_destroy(prod);
        complex_destroy(quot);
        complex_destroy(power);
        for (int i = 0; i < n; i++) {
            complex_destroy(roots[i]);
        }
        complex_destroy(exp);
        complex_destroy(log);
        complex_destroy(sin);
        complex_destroy(cos);
    }
}

3. 总结

通过上述步骤，我们成功地将C++类导出为DLL，并在C#中通过P/Invoke调用这些导出的函数。这样，我们就可以在C#中使用C++编写的复数运算类，并调用其构造函数和方法。

希望这个解决方案能帮助你解决问题。如果有任何疑问或需要进一步的帮助，请随时提问。

如果该回答解决了您的问题，请采纳！如果没有，请私信联系或评论您的疑惑