尝试学习课程和“堆” C ++

Question

So, I am pretty confused on the below code. It its directly quoted from C++ for Dummies 5th ed, minus the comments I made.

class student{
public:
    int semesterHours;
    float gpa;
    student valFriend; //I thought to use the name of the class as a data type
    student& refFriend;
    student* ptrFriend; 
}; //then this line should read .. '}student;' to enable something like the above

int main()
{
    student& student = *new student; //new student object 'student'
    student.gpa = 2.0;

    student& studentFriend = *new student; //new student object 'studentFriend'
    studentFriend.gpa = 4.0;

    student.valFriend = studentFriend;

    student.pFriend = &studentFriend;

}

Within the class 'student' are those objects of itself? How is that even possible? If I am looking at this correctly, are two new objects being allocated off the heap with the respective names 'student' and 'studentFriend' using the new function?

Then the object student.valFriend is being assigned all values that are of the object 'studentFriend.'

The last bit of code appears to me to be assigning some undeclared member object of the class 'student' the reference of studentFriend? Perhaps someone could explain this one a bit more explicitly. A simply fix is that possibly in the text it was meant to be 'student.ptrFriend,' but would they not have saw that? Maybe I'm the one missing something. Otherwise, I don't understand the syntax of this line.

On top of all this, the code does not even compile. What is going on here? I suppose the reason for not compiling could be because it is just a bit of code in a section about referencing and pointers. Nonetheless, it is still confusing.

Answer 1

It won't compile for the following reasons:

class student{
public:
    int semesterHours;
    float gpa;
    student valFriend; // this line is full of evil!
    student& refFriend;
    student* ptrFriend;
};

Just think for a while. A student can save the value of a student, which can save a value of a student, which can save a value.... You're building an object of infinite size. You can't store an object inside of itself.

student& student . You want to name a variable student . But student is already a taken name (it's the name of your class). Also, you can't change a reference. Once you made a reference it's fixed. So if a struct / class contains a reference it must be initialized while constructing the object:

class student{
public:
    student(student& myFriend):refFriend(myFriend), ptrFriend(0){}
    // if a student has no friend, we say he's his own friend:
    student():refFriend(*this), ptrFriend(0){}        
    int semesterHours;
    float gpa;    
    student& refFriend;
    student* ptrFriend;
};

int main()
{
    student& myStudent = *(new student);   //new student object 'student'
    myStudent.gpa = 2.0;

    student& studentFriend = *new student; //new student object 'studentFriend'
    studentFriend.gpa = 4.0;    

    myStudent.ptrFriend = &studentFriend;
}

However, there are some really creepy things going on there. Why do you want do allocate dynamic memory and store a reference to it? How are you going to deallocate? Using delete &myStudent ? This is wrong on many, many levels. It's better to use pointer to dynamic memory or use automatic storage objects:

class student{
public:
    student(student& myFriend):refFriend(myFriend){}
    student():refFriend(*this){}
    int semesterHours;
    float gpa;    
    student& refFriend;
    student* ptrFriend;
};

int main()
{
    student myStudent;
    myStudent.gpa = 2.0;

    student studentFriend;
    studentFriend.gpa = 4.0;

    myStudent.ptrFriend = &studentFriend;
}

Although your kind of style will result in valid C++ code, I would never ever use it since it's very hard to find errors. Find a good book, understand references, pointers and dynamic memory.

Answer 2

If this comes from a book, look for something else, please. It's quite an achievement to get this many coding errors in so few lines ;)

First: you can't declare a member of an unknown class:

class student{
public:
    // ...
    student valFriend; //<- impossible, class student is not known, yet
    student& refFriend; // impossible without initialization constructor
    // ...
};    

second: besides the code being invalid, never dereference a pointer retrieved by new or malloc - the memory will most likely be lost (aka leak) because you forget to delete it later. You can do something like this for this specific sample:

student james;
student jim;

james.ptrFriend = &jim; // stores the pointer to jim

Other than that, please check Stack and Heap explained and Classes explained for better explanation and in-depth information.