Erstellen einer benutzerdefinierten Klasse in C++ mit Konstruktorwerten

Question

Ich lerne immer noch C++ und habe viel Erfahrung mit Java. In Java kann eine Klasse erstellen so einfach wie diese:

public class vertex 
{ 

public double x, y, z; 

public boolean eliminated = true; 


public vertex(double x, double y, double z) 
{ 
    //vertex constructor 
} 

} 

Ich versuche, etwas ziemlich identisch in C++ zu tun, denn gebaut speichern Funktionen „get“ für die Werte der Rückkehr, die eingestellt werden soll, wenn Erstellen einer Instanz der Klasse und möchte wissen, ob meine Syntax korrekt ist. Hier ist die Klasse:

#include <iostream> 
#include <stdlib.h> 

using namespace std; 

class Vertex // Standard way of defining the class 
{ 

public: 
    // This means that all of the functions below this(and any variables) are accessible to the rest of the program. 

    Vertex(double x, double y, double z); 
    //constructor 

    double getX(); 
    double getY(); 
    double getZ(); 

    double x; 
    double y; 
    double z; 


}; 

double Vertex:: getX() 
{ 
    return x; 
} 

möchte ich auch Ratschläge zum Erstellen einer Klasse, die Instanzen von benutzerdefinierten Klassen wie die aboce in ihnen hat.

Answer 1

public class vertex 
{ 
    public double x, y, z; 
    public boolean eliminated = true; 
    public vertex(double x, double y, double z) 
    { 
    //vertex constructor 
    } 
} 

Um diese Java-Klasse so einfach und so genau wie möglich in C++ nachahmen würden Sie dies tun:

struct vertex{ 
    double x, y, z; 
    bool eliminated = true; 
    vertex(double x, double y, double z){ 
     //vertex constructor 
    } 
}; 

täuschend ähnlich und richtig? Beachten Sie, dass der Member eliminated standardmäßig initiiert ist, was für C++ 11 neu ist. Stellen Sie also sicher, dass Sie über einen aktuellen Compiler verfügen. struct wird anstelle der Klasse verwendet, da alle Ihre Mitglieder sowieso öffentlich sind. Sie können auch class und den Zugriffsspezifizierer public: verwenden. Sie benötigen keine Zugriffsmethoden (Getter), da alles bereits öffentlich ist, wie in Ihrer Java-Klasse.

Sie benötigen keine Includes für Ihre Vertex-Klasse Definitionen und Sie sollten definitiv keine using Deklaration irgendwelche Header-Dateien setzen.

Um den Java-Methodenparameter nachzuahmen, übergeben Sie Kopien für Primitive und nicht-konstante Zeiger (keine Referenzen) für Objektinstanzparameter.

bearbeiten - reparierte die dummen Fragen, die ich verpasst, und dass die menschliche Compiler unter getupft :)

Answer 2

Dies könnte Ihnen helfen:

Vector3.h

#ifndef VECTOR3_H 
#define VECTOR3_H 

namespace myNamespace { // Add This Because Many Libraries may define a Vector3 Object 

class Vector3 { 
    union { 
     float m_f3[3]; 
     struct { 
      float m_fx; 
      float m_fy; 
      float m_fz; 
     }; 
    }; 

    inline Vector3(); 
    inline Vector3(float x, float y, float z); 
    inline Vector3(float *pfv); 
    ~Vector3(); 

    // Add Your inline overloaded operators & inline function declarations here. 
}; 

#include "Vector3.inl" 

} // namespace myNameSpace 

#endif // VECTOR3_H 

Vector3 .inl

// ------------------------------------------------------ 
// Vector3() - Default Constructor Sets All Values To 0 
inline Vector3::Vector3() : 
m_fx(0), 
m_fy(0), 
m_fz(0) { 
} // Vector3 

// ------------------------------------------------------ 
// Vector3() - Takes (x,y,z) Parameters 
inline Vector3::Vector3(float x, float y, float z) : 
m_fx(x), 
m_fy(y), 
m_fz(z) { 
} // Vector3 

// ------------------------------------------------------ 
// Vector3() - Takes A Pointer To Type 
inline Vector3::Vector3(float *pfv) : 
m_fx(pfv[0]), 
m_fy(pfv[1]), 
m_fz(pfv[2]) { 
} // Vector3 

Vector3.cpp

#include "Vector3.h" 

namespace myNamespace { 

// ---------------------------------------------- 
// ~Vector3() - Default Destructor - Does Nothing 
// Only Defined Here So That There Is Some Type Of Translation 
// Unit In The Object File Generated When Compiling 
Vector3::~Vector3() { 
} // ~Vector3 

} // namespace myNamespace 

diese zu benutzen:

main.cpp

#include <iostream> 
#include "Vector3.h" 

int main() { 
    using namespace myNamespace; // Forgot to add this line here. 

    Vector3 v1; 

    std::cout << "Default Constructor Used: " << std::endl; 
    std::cout << "v1 = (" << v1.m_fx << ", " 
          << v1.m_fy << ", " 
          << v1.m_fz << ")" << std::endl; 
    // Or This Way Works Too 
    std::cout << "v1 = (" << v1.m_f3[0] << ", " 
          << v1.m_f3[1] << ", " 
          << v1.m_f3[2] << ")" << std::endl; 

    Vector3 v2(2.2f, 3.3f. 4.4f); 
    std::cout << "2nd Constructor Used: " << std::endl; 
    std::cout << "v2 = (" << v2.m_f3[0] << ", " 
          << v2.m_f3[1] << ", " 
          << v2.m_f3[2] << ")" << std::endl; 


    float f3[3] = { 4.5f, 6.7f, 8.9f }; 
    Vector3 v3(f3); 
    std::cout << "3rd Constructor Used: " << std::endl; 
    std::cout << "v3 = (" << v3.m_fx << ", " 
          << v3.m_f3[1] << ", " 
          << v3.m_fz << ")" << std::endl; 

} // main 

EDIT:

Wenn Sie eine eine Klasse, die enthält Instanzen von ein anderer Benutzer definiert Klasse, dann ist es so einfach:

SomeClass.h

#ifndef SOME_CLASS_H 
#define SOME_CLASS_H 

namespace myNamespace { 

class Vector3; 

class SomeClass { 
private: 
    Vector3 m_currentPosition; 
    Vector3 m_velocity; 
    Vector3 m_finalPosition; 

public: 
    SomeClass(Vector3 initialPosition, Vector3 currentVelocity); 

    Vector3 getFinalPosition() const; 

private: 
    void calculateFinalPosition(); 
}; 

} // namespace myNamespace 

SomeClass.cpp

#include "SomeClass.h" 
#include "Vector3.h" 

namespace myNamespace { 

SomeClass::SomeClass(Vector3 initialPosition, Vector3 currentVelocity) : 
m_currentPosition(initialPosition), 
m_velocity(currentVelocity) { 
    calculateFinalPosition(); 
} 

Vector3 SomeClass::getFinalPosition() const { 
    return m_finalPosition; 
} // getFinalPosition 

void SomeClass::calculateFinalPosition() { 
    // Perform The Appropriate Calculation Here To Find The Final Position 
} // calculateFinalPosition 

} // namespace myNamespace 

jedoch für diese zu arbeiten; Dies würde erfordern, dass der Vector3 die überladenen Operatoren, Funktionen wie Kreuz, Punkt usw., definiert.