如何转换一个"；ArrayList<；ClassNod>&引用；用Java编写成C++；程序语言？

我用Java编写了一个名为Nod.Java的类

import java.util.ArrayList;
import java.util.Arrays;

class Nod {
        int[] vol;
        String op="";
        Nod parent; 
        int adancime;

        Nod (int[] vol, String op,Nod parent,int adancime){             
            this.vol=vol;
            this.op=op;
            this.parent = parent;
            this.adancime=adancime;
            }

        public String toString() {
        return op;
        }

        public int getAdancime() {
                return adancime;
        }

        public ArrayList<Nod> getCale(ArrayList<Nod> lnoduri) {
        lnoduri.add(0, this);
        if (parent != null) lnoduri = parent.getCale(lnoduri);
        return lnoduri;
        }

        public ArrayList<Nod> getCale() 
        { return(getCale(new ArrayList<Nod>())); }
}

import java.util.ArrayList；
导入java.util.array；
班级点头{
国际[]卷；
字符串op=“”；
点头表示同意；
国际亚丹西；
Nod（int[]vol，String op，Nod parent，int adancime）{
这个.vol=vol；
this.op=op；
this.parent=parent；
this.adancime=adancime；
}
公共字符串toString（）{
返回op；
}
公共int getAdancime（）{
返回adancime；
}
公共ArrayList getCale（ArrayList lnoduri）{
添加（0，这个）；
如果（parent！=null）lnoduri=parent.getCale（lnoduri）；
返回lnoduri；
}
公共阵列列表getCale（）
{return（getCale（newarraylist（））；}
}

<>我想用C++重写，但是我不知道如何在C++中重写这两个函数：

public ArrayList<Nod> getPath(ArrayList<Nod> lnoduri) {
    lnoduri.add(0, this);
    if (parent != null) lnoduri = parent.getPath(lnoduri);
    return lnoduri;
}

public ArrayList<Nod> getPath(){ 
    return(getPath(new ArrayList<Nod>())); 
}

public ArrayList getPath（ArrayList lnoduri）{
添加（0，这个）；
如果（parent！=null）lnoduri=parent.getPath（lnoduri）；
返回lnoduri；
}
公共ArrayList getPath（）{
返回（getPath（newarraylist（））；
}

这些函数存储每个节点到父节点的路径

你能帮我吗

编辑

因为这是一个相关的问题，我在这里加上它

我用Java为“Vase”类编写了一个函数：

public ArrayList<Nod> succesori(Nod parent) {

    // "Nod" is another class.                          
    ArrayList<Nod> listTest = new ArrayList<Nod>();

    // operations/conditions;

    listTest.add(new Nod(vol,op,parent,adancime+1));
    return(listTest);
}

public ArrayList succesori（节点父节点）{
//“点头”是另一门课。
ArrayList listTest=新的ArrayList（）；
//操作/条件；
添加（新节点（vol，op，parent，adancime+1））；
返回（列表测试）；
}

我想用C++重写：

vector<Nod*> Vase::succesori(Nod *parinte)
{
    vector<Nod*> *listTest = new vector<Nod*>();

    // operations/conditions;

    listTest.insert(new Nod(vol,op,parent,adancime+1)); 
    return (*listTest);
    }

向量花瓶：：成功（Nod*parint） { vector*listTest=新向量（）； //操作/条件； 插入（新节点（卷、op、父节点、adancime+1））； 返回（*列表测试）； } 但我在尝试执行此命令时出错： 插入（新节点（卷、op、父节点、adancime+1））

IntelliSense:表达式必须具有类类型

错误1错误C2228:“.insert”的左侧必须具有类/结构/联合

---

如何在listTest中添加/插入新的Node类？

Java代码看起来有点奇怪。如果您真的想使用递归，那么我建议您按照如下方式重写这些方法

public void getCale(ArrayList<Nod> lnoduri) {
    if (parent != null) {
        parent.getCale(lnoduri);
    }
    lnoduri.add(this);
}

public ArrayList<Nod> getCale() {
    ArrayList<Nod> result = new ArrayList();
    getCale(result);
    return result;
}

public void getCale（ArrayList lnoduri）{
如果（父项！=null）{
parent.getCale（lnoduri）；
}
添加（这个）；
}
公共阵列列表getCale（）{
ArrayList结果=新建ArrayList（）；
getCale（结果）；
返回结果；
}

<>在C++中，我只使用一个成员函数。

std::vector<Nod*> getCale()
{
    std::vector<Nod*> result;
    for (Nod* n = this; n; n = n->_parent) {
        result.push_back(n);
    }
    std::reverse(result.begin(), result.end());
    return result;
}

std:：vector getCale（）
{
std：：向量结果；
对于（Nod*n=this；n；n=n->\u parent）{
结果：推回（n）；
}
std:：reverse（result.begin（），result.end（））；
返回结果；
}

Java代码看起来有点奇怪。如果您真的想使用递归，那么我建议您按照如下方式重写这些方法

public void getCale(ArrayList<Nod> lnoduri) {
    if (parent != null) {
        parent.getCale(lnoduri);
    }
    lnoduri.add(this);
}

public ArrayList<Nod> getCale() {
    ArrayList<Nod> result = new ArrayList();
    getCale(result);
    return result;
}

public void getCale（ArrayList lnoduri）{
如果（父项！=null）{
parent.getCale（lnoduri）；
}
添加（这个）；
}
公共阵列列表getCale（）{
ArrayList结果=新建ArrayList（）；
getCale（结果）；
返回结果；
}

<>在C++中，我只使用一个成员函数。

std::vector<Nod*> getCale()
{
    std::vector<Nod*> result;
    for (Nod* n = this; n; n = n->_parent) {
        result.push_back(n);
    }
    std::reverse(result.begin(), result.end());
    return result;
}

std:：vector getCale（）
{
std：：向量结果；
对于（Nod*n=this；n；n=n->\u parent）{
结果：推回（n）；
}
std:：reverse（result.begin（），result.end（））；
返回结果；
}
 你可以直接向C++写翻译，但是如果你这样做，程序可能会很难维护和慢。请记住，默认情况下，所有方法都是虚拟的，对象通过指针传递，并且
vector
替换
ArrayList
：

virtual vector<nod*> *getCale(vector<nod*> *lnoduri) {
    lnoduri->insert(lnoduri->begin(), this);
    if (parent != nullptr) lnoduri = parent->getCale(lnoduri);
    return lnoduri;
}

virtual vector<nod*> *getCale() {
    return getCale(new vector<nod*>());
}

虚拟向量*getCale（向量*lnoduri）{
lnoduri->insert（lnoduri->begin（），这是）；
if（parent！=nullptr）lnoduri=parent->getCale（lnoduri）；
返回lnoduri；
}
虚拟向量*getCale（）{
返回getCale（新向量（））；
}
 你可以直接向C++写翻译，但是如果你这样做，程序可能会很难维护和慢。请记住，默认情况下，所有方法都是虚拟的，对象通过指针传递，并且
vector
替换
ArrayList
：

virtual vector<nod*> *getCale(vector<nod*> *lnoduri) {
    lnoduri->insert(lnoduri->begin(), this);
    if (parent != nullptr) lnoduri = parent->getCale(lnoduri);
    return lnoduri;
}

virtual vector<nod*> *getCale() {
    return getCale(new vector<nod*>());
}

虚拟向量*getCale（向量*lnoduri）{
lnoduri->insert（lnoduri->begin（），这是）；
if（parent！=nullptr）lnoduri=parent->getCale（lnoduri）；
返回lnoduri；
}
虚拟向量*getCale（）{
返回getCale（新向量（））；
}
将java编写的C++语言转换为C++的最佳方法是重新设计整个过程；这两种语言的语义和习语完全不同。例如，这个类有任何子类吗？是否有任何子类覆盖了
getPath
？在已回答的问题上添加另一个问题是个坏主意。不过，您仍然在混合指针和非指针。代码应该如下所示：
vector Vase:：succession（Nod*parent）{vector listTest；listTest.insert（new Nod（…）；return listTest；}
为此感到抱歉。。。下次我将提出一个新问题。我写下了你说的话，我得到了另一个错误：“错误1错误C2661:‘std:：vector:：insert’：没有重载函数接受1个参数”和“IntelliSense:没有重载函数的实例”std:：vector:：insert[with _Ty=Nod*，_Ax=std:：allocator]“匹配参数列表”和“IntelliSense:函数调用中的参数太少”。插入有问题…我用了“push_back”代替了“insert”，现在它可以工作了。谢谢你的回答！将java编写的东西转换成C++的最好方法是重新设计整个过程；这两种语言的语义和习语完全不同。例如，这个类有任何子类吗？是否有任何子类重写了
getPath
？这是一个错误的id