Fatal编程技术网
  • cplusplus/
  • C++ 在对象内的数组中设置值

C++ 在对象内的数组中设置值

c++ arrays object

C++ 在对象内的数组中设置值,c++,arrays,object,C++,Arrays,Object,我对对象中的对象数组有问题： 我有一个带有对象数组的类： class element { public: element() {}; LinePiece* arrayLP; 我在数组中有一个类： class LinePiece { public: LinePiece() {}; AnsiString Type; int ElementNr; int Status; int X, Y; 因此，在元素对象中，我有一个线条数组。奇怪的是，当我填写ElementArray[1].LPArray[

我对对象中的对象数组有问题：

我有一个带有对象数组的类：

class element
{
public:
element() {};
LinePiece* arrayLP;
我在数组中有一个类：

class LinePiece
{
public:
LinePiece() {};

AnsiString Type;
int ElementNr;
int Status;
int X, Y;
因此，在元素对象中，我有一个线条数组。奇怪的是，当我填写ElementArray[1].LPArray[0]时；它被下一个对象（ElementArray[2].LPArray[0]覆盖

我用以下代码填充它：

String FileBuffer;
String Regel;
String Code;

element* GetElementInfo()
{
//alle onderdelen van een Elementobject
String OrderNumber;             //ON
String OrderBrand;              //MO
String ElementNumber;           //SN
String ElementMarking;          //RS
String ReinforcementPattern;    //OW
String CalculationNumber;       //CN
String ElementLength;           //LE
String ElementWidth;            //WD
String ElementBeginX;           //BP
String ConcreteThickness;       //TH
String Isulation;               //IH
String Weight;                  //NW

element *ElementArray = new element[100];
LinePiece *LPArray = new LinePiece[100];
bool firstElement = true;
int Index =0;
int LPIndex = 0;

for(int i = 1; i <= FileBuffer.Length(); i++)
{
    if(FileBuffer[i] != 0)
    {
        if(FileBuffer[i] != IntToStr('\r'))  //controleren of je op einde regel zit, zoniet vul de string "regel" aan
        {
            if(FileBuffer[i] != IntToStr('\r') && FileBuffer[i] != IntToStr('\n'))
            {
                Regel = Regel + FileBuffer[i];
            }
        }
        else //kijken wat er op de regel staat
        {
            Code = Regel.SubString(0,2);

            if(Code == "ON") //Ordernummer
            {
                OrderNumber = Regel.SubString(4, (Regel.Length() -3));
                Regel = "";
            }
            if(Code =="MO")  //Ordermerk
            {
                 OrderBrand = Regel.SubString(4, (Regel.Length() -3));
                 Regel = "";
            }

            if(Code =="SN")  //Element nummer
            {
                ElementNumber = Regel.SubString(4, (Regel.Length()-3));
                Regel = "";
            }

            if(Code =="RS") //Element marking
            {
                ElementMarking = Regel.SubString(4, (Regel.Length()-3));
                Regel = "";
            }

            if(Code =="CN") //Calculatienummer
            {
                CalculationNumber = Regel.SubString(4, (Regel.Length()-3));
                Regel = "";
            }

            if(Code == "LE") //Element lengte
            {
                ElementLength = Regel.SubString(4,(Regel.Length()-3));
                Regel = "";
            }

            if(Code == "WD") //element breedte
            {
                ElementWidth = Regel.SubString(4,(Regel.Length()-3));
                Regel = "";
            }

            if(Code == "BP") //beginpunt X
            {
                ElementBeginX = Regel.SubString(4, (Regel.Length()-3));
                Regel = "";
            }
            if (Code == "OW") //Wapeningspatroon
            {
                ReinforcementPattern = Regel.SubString(4, (Regel.Length()-3));
                Regel = "";
            }
            if(Code == "TH")  //Beton dikte
            {
                ConcreteThickness = Regel.SubString(4,(Regel.Length()-3));
                Regel = "";
            }

            if(Code == "IH") //isolatie dikte
            {
                Isulation = Regel.SubString(4,(Regel.Length()-3));
                Regel = "";
            }

            if(Code == "NW")  //Gewicht
            {
                Weight = Regel.SubString(4, (Regel.Length()-3));
                Regel = "";
            }

            if(Code == "CO") //Contour
            {
                String geheleRegel = Regel.SubString(4, (Regel.Length() -3));

                int EleNr = 0;
                int Status = 0;
                //geheleRegel doormidden hakken voor x en y waardes.
                String X = geheleRegel.SubString(0, (geheleRegel.Length() /2));
                String Y = geheleRegel.SubString(geheleRegel.Length()/2 +1, geheleRegel.Length());

                LinePiece lpObject(Code, EleNr, Status, StrToInt(X), StrToInt(Y));
                LPArray[LPIndex] = lpObject;
                LPIndex++;
                Regel = "";
            }


            if(Code == "*" && firstElement == false) //Nieuw element
            {
                if(OrderNumber == "")
                {
                    OrderNumber =="-";
                }

                if(OrderBrand == "")
                {
                    OrderBrand = "-";
                }

                if(ElementNumber == "")
                {
                    ElementNumber = "-";
                }

                if(ElementMarking == "")
                {
                    ElementMarking = "-";
                }

                if (ReinforcementPattern == "")
                {
                    ReinforcementPattern = "-";
                }

                if (CalculationNumber == "")
                {
                    CalculationNumber = "-";
                }

                if(ElementLength == "")
                {
                    ElementLength = 0;
                }

                if(ElementWidth == "")
                {
                    ElementWidth = 0;
                }

                if(ElementBeginX == "")
                {
                    ElementBeginX = 0;
                }

                if(ConcreteThickness == "")
                {
                    ConcreteThickness = 0;
                }

                if(Isulation == "")
                {
                    Isulation = 0;
                }

                if(Weight == "")
                {
                    Weight = 0;
                }

                element ElementObject(OrderNumber, OrderBrand, ElementNumber, ElementMarking,
                ReinforcementPattern, CalculationNumber, StrToInt(ElementLength), StrToInt(ElementWidth),
                StrToInt(ElementBeginX), StrToInt(ConcreteThickness),StrToInt(Isulation),
                Weight, LPArray);

                ElementArray[Index] = ElementObject;
                LPIndex = 0;    /resetting LPIndex
                Index++;
            }
            else  
            {
                Regel="";
            }

            if (Code == "*")
            {
                 firstElement = false;
            }
        }

    }
}
return ElementArray;
}

字符串文件缓冲区；
字符串Regel；
字符串代码；
元素*GetElementInfo（）
{
//alle Onderelen van een元素对象
字符串OrderNumber；//打开
字符串OrderBrand；//MO
字符串ElementNumber；//SN
字符串元素标记；//RS
字符串增强模式；//OW
字符串CalculationNumber；//CN
String ElementLength；//LE
String ElementWidth；//WD
String ElementBeginX；//BP
字符串的具体厚度；//TH
字符串计算；//IH
字符串重量；//NW
element*ElementArray=新元素[100]；
线条*LPArray=新线条[100]；
bool firstElement=true；
int指数=0；
int-LPIndex=0；

对于（int i=1；i您的初始化代码应该如下所示：


element *ElementArray = new element[100];
for ( int n = 0; n < 100; ++n )
  ElementArray[n].arrayLP = new LinePiece[100];



element*ElementArray=新元素[100]；
对于（int n=0；n<100；++n）
ElementArray[n].arrayLP=新线条[100]；


因此，您描述的行为可能是由于未定义的行为


您似乎不会在任何地方删除分配的数组-这将导致内存泄漏。此外，如果您想要数组而不是向量，则必须遵守三条规则（添加复制构造函数/运算符和析构函数）.
你是否只分配一个
线条
数组，并将其用于每个
元素
？此外，你最好使用
std:：vector
而不是动态数组。你能发布包含循环的完整代码吗？我认为这样会让人困惑。是的，我只是使用1
线条
数组，并为每个元素重新填充它新对象。当我首先用
线条
数组填充
ElementObject
时，这应该不是问题？@Bart如果你对每个元素使用相同的数组，当然修改一个会改变其他元素，它是相同的数组。@Bart数组在传递时不会被复制。如果你想要一个具有值语义的数组，你可以n在C++11中使用
std:：array
。我不知道
100
元素是否只是一个任意大小的元素，但如果是，您应该使用
std:：vector
来获得一个动态的、可调整大小的集合。@Bart而不是
LinePiece*
添加
std:：vector
，对于ElementArray也是如此。然后使用
ElementArray、 调整（100）
和
的大小（int n=0；n
。如果我想动态保留向量呢？就像我不想给它们一个大小一样？你可以随时调用向量上的
调整大小（newSize）
。