Errore: identificatore del tipo previsto prima di 'ClassName'

Question

shared_ptr<Shape> circle(new Circle(Vec2f(0, 0), 0.1, Vec3f(1, 0, 0))); 

shared_ptr<Shape> rect(new Rect2f(Vec2f(0, 0), 5.0f, 5.0f, 0, 
            Vec3f(1.0f, 1.0f, 0))    ); 

Sto cercando di capire perché quanto sopra non verrà compilato. Per una qualche ragione, quando cerco di creare un'istanza di Rect2f (che ereditano dalla classe Shape specificato l'argomento shared_ptr modello, proprio come Circle), ottengo il seguente errori:

error: expected type-specifier before 'Rect2f' 
error: expected ')' before 'Rect2f' 

Tutto sulla Circleshared_ptr è perfettamente a posto. Non ci sono problemi con esso; è solo il Rect2f che causa problemi.

Inoltre, i valori passati nel costruttore sono validi.

Quindi, quale potrebbe essere il problema con questo? Ho incluso Rect.h per questo. Per l'amor di brevità (e incassa ho perso qualcosa in quel file, che possono influenzare questo), vi posterò la seguente:

Rect.h

#pragma once 

#include <QGLWidget> 
#include <GL/glext.h> 
#include <cmath> 
#include <QDebug> 
#include "Shape.h" 
#include "Vec3f.h" 
#include "rand.h" 

const int DEFAULT_SQUARE_WIDTH = 5; 
const int DEFAULT_SQUARE_HEIGHT = 5; 

typedef enum { 
    RC_TOPLEFT, 
    RC_TOPRIGHT, 
    RC_BOTTOMRIGHT, 
    RC_BOTTOMLEFT 
} RectangleCorner; 

class Rect2f : public Shape 
{ 
public: 

    Rect2f(
     Vec2f center = Vec2f(), 
     float width = 4, 
     float height = 4, 
     float radius = 0, 
     Vec3f color = Vec3f() 
    ); 

    ~Rect2f(); 

    inline const float GetWidth(void) const { 
     return mWidth; 
    } 

    inline const float GetHeight(void) const { 
     return mHeight; 
    } 

    inline const Vec2f* GetCorner(RectangleCorner rc) const { 
     switch(rc) { 
     case RC_TOPLEFT: 
      return mTopLeftCrnr; 
      break; 

     case RC_TOPRIGHT: 
      return mTopRightCrnr; 
      break; 

     case RC_BOTTOMLEFT: 
      return mBottomLeftCrnr; 
      break; 

     case RC_BOTTOMRIGHT: 
      return mBottomRightCrnr; 
      break; 
     } 
    } 

    void UpdateCorners(); 

    virtual void Collide(Shape &s); 

    virtual void Collide(Rect2f &r); 

    virtual void Collide (Circle &c); 

    virtual bool Intersects(const Shape& s) const; 

    virtual bool Intersects(const Rect2f& s) const; 

    virtual bool IsAlive(void) const; 

    virtual float Mass(void) const; 

protected: 

    virtual void Draw(void) const; 
    float mWidth, mHeight; 
    Vec3f mColor; 

private: 
    Vec2f* mTopLeftCrnr; 
    Vec2f* mTopRightCrnr; 
    Vec2f* mBottomLeftCrnr; 
    Vec2f* mBottomRightCrnr; 

}; 

Fonte di funzione di errore e file di intestazione (mainwindow.cpp)

#include "ui_mainwindow.h" 
#include "Vec2f.h" 
#include "Rect2f.h" 
#include "SharedPtr.h" 

MainWindow::MainWindow(QWidget *parent) : 
    QMainWindow(parent), 
    ui(new Ui::MainWindow) 
{ 
    ui->setupUi(this); 

    BoxOfShapes* display = new InteractiveBoxOfShapes(this, 600, 600); 
    ui->mGridLayout->addWidget(display); 
    ui->mStatusBar->showMessage("status ok"); 

    QObject::connect(display, SIGNAL(numShapesChanged(int)), this, SLOT(setNumShapes(int))); 
    QObject::connect(ui->mResetButton, SIGNAL(pressed()), display, SLOT(resetWorld())); 
    shared_ptr<Shape> circle(
       new Circle(
        Vec2f(0, 0), 
        0.1, 
        Vec3f(1, 0, 0))); 
    /*std::shared_ptr<Shape> rect(<---error 
        new Rect2f(
         Vec2f(0, 0), 
         5.0f, 
         5.0f, 
         0, 
         Vec3f(1.0f, 1.0f, 0) 
        ) 
       );*/ 
    shared_ptr<Shape> rect(new Rect2f()); //error - second attempt 
    display->addShape(circle); 
    display->addShape(rect); 
} 

principale Function test (main.cpp)

#include <QtGui/QApplication> 
#include "mainwindow.h" 
#include "Rect2f.h" 

int main(int argc, char *argv[]) 
{ 
    Rect2f rec; 

    QApplication a(argc, argv); 
    MainWindow w; 
    w.show(); 

    return a.exec(); 
} 

Domanda

A giudicare dalle errori previsti, quello che mi manca qui? Inoltre, cosa si può fare per correggere questo problema?

Answer 1

Prima di tutto, cerchiamo di rendere il codice un po 'più semplice:

// No need to create a circle unless it is clearly necessary to 
// demonstrate the problem 

// Your Rect2f defines a default constructor, so let's use it for simplicity. 
shared_ptr<Shape> rect(new Rect2f()); 

Bene, ora vediamo che le parentesi sono chiaramente equilibrata. Cos'altro potrebbe essere? Controlliamo il following code snippet's error:

int main() { 
    delete new T(); 
} 

questo può sembrare strano l'uso, e lo è, ma io odio le perdite di memoria. Tuttavia, l'output sembra utile:

In function 'int main()': 
Line 2: error: expected type-specifier before 'T' 

Aha! Ora ci rimane solo l'errore relativo alle parentesi. Non riesco a trovare cosa lo causa; tuttavia, penso che ti stai dimenticando di includere il file che definisce Rect2f.

Answer 2

Dalla discussione dalla prima risposta: http://chat.stackoverflow.com/rooms/6681/discussion-between-holland-and-anton-golov

Anton: It gives me the error "cannot allocate an object of abstract type ‘Rect2f’ because the >following virtual functions are pure within ‘Rect2f’: virtual bool Shape::Intersects(const >Circle&) const".

Sembra che vi state perdendo questa funzione dal Rect2f classe:

virtual bool Intersects(const Circle& c) const;

Answer 3

Per le persone in futuro alle prese con un problema simile, la situazione è che il compilatore semplicemente non riesce a trovare il tipo che stai usando (anche se il tuo Intelisense può trovarlo).

Ciò può essere causato in molti modi:

• Hai dimenticato di #include l'intestazione che lo definisce.
• Le protezioni di inclusione (#ifndef BLAH_H) sono difettose (il tuo #ifndef BLAH_H non corrisponde al tuo #define BALH_H a causa di un errore di digitazione o copia + incolla).
• Oppure, il compilatore sta pensando si intende un ambito, quando in realtà si intende un altro (ad esempio, se si dispone di NamespaceA::NamespaceB, ed un <global scope>::NamespaceB, se sei già entro NamespaceA, sarà cercare nella NamespaceA::NamespaceB e non preoccuparsi di verificare <global scope>::NamespaceB) a meno che non lo si acceda esplicitamente.

Per accedere esplicitamente qualcosa nello spazio dei nomi globale, prefisso con ::, come se lo spazio dei nomi globale è uno spazio dei nomi senza nome (ad esempio ::MyType o ::MyNamespace::MyType).