Question

我发布了我项目的所有文件，似乎做得正确，但这个错误对我来说是不可能的......

mainwindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>
#include <activemq/library/ActiveMQCPP.h>
#include <decaf/lang/Thread.h>
#include <decaf/lang/Runnable.h>
#include <decaf/util/concurrent/CountDownLatch.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/System.h>
#include <activemq/core/ActiveMQConnectionFactory.h>
#include <activemq/util/Config.h>
#include <cms/Connection.h>
#include <cms/Session.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/MapMessage.h>
#include <cms/ExceptionListener.h>
#include <cms/MessageListener.h>
#include "IfacomAmqSender.h"

using namespace activemq::core;
using namespace decaf::util::concurrent;
using namespace decaf::util;
using namespace decaf::lang;
using namespace cms;

namespace Ui {
class MainWindow;
}


class MainWindow : public QMainWindow,public MessageListener
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();
    void onMessage(const Message*);
    void connetionSender();

    IfacomAmqSender m_IfacomMessageBroker;

private slots:
    void on_pushButton_clicked();

private:
    Ui::MainWindow *ui;
};

#endif // MAINWINDOW_H

mainwindow.cpp

#include "mainwindow.h"
#include "ui_mainwindow.h"
#include "IfacomAmqSender.h"
#include "IfacomAmqReceiver.h"
#include <activemq/library/ActiveMQCPP.h>
#include <decaf/lang/Thread.h>
#include <decaf/lang/Runnable.h>
#include <decaf/util/concurrent/CountDownLatch.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/System.h>
#include <activemq/core/ActiveMQConnectionFactory.h>
#include <activemq/util/Config.h>
#include <cms/Connection.h>
#include <cms/Session.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/MapMessage.h>
#include <cms/ExceptionListener.h>
#include <cms/MessageListener.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <memory>
#include <qstring.h>
#include <QTextStream>
#include <QMessageBox>


using namespace activemq::core;
using namespace decaf::util::concurrent;
using namespace decaf::util;
using namespace decaf::lang;
using namespace cms;
using namespace std;



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



    MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::connetionSender()
{
    activemq::library::ActiveMQCPP::initializeLibrary();

    std::string brokerURI  = "failover://(tcp://localhost:61613?wireFormat=stomp)";     // localhost;

    // brokerURI = "failover://(tcp://localhost:61616)";        // localhost

    // Queue name
    std::string destName = "IFACOM-CMS";

    // Queue or Topic 
    bool useTopics = false;         // true=Topic, false=Queue

    // SESSION_TRANSACTED or AUTO_ACKNOWLEDGE
    bool sessionTransacted = false; // if true, commit all messages



    // ***** Initialisation  **************************************************************
    IfacomAmqSender m_IfacomMessageBroker(brokerURI, useTopics, sessionTransacted, destName);
    m_IfacomMessageBroker.initConnection();

    IfacomAmqReceiver IfacomAmqReceiverBroker(brokerURI,10, useTopics, sessionTransacted, destName,2000);
    IfacomAmqReceiverBroker.initConnection();
    IfacomAmqReceiverBroker.getConsumer()->setMessageListener(this);

 }


    void MainWindow::on_pushButton_clicked()
    {
    //****** Send message ******************************************************

        //IfacomAmqSender IfacomAmqReceiverBroker;

    std::string text = "My IFaCOM message";
    // Customized message
    try{
        std::auto_ptr<TextMessage> message(m_IfacomMessageBroker.getSession()->createTextMessage(text));
        message->setCMSTimestamp(System::currentTimeMillis());
        message->setStringProperty("MyProperty", "test");
        m_IfacomMessageBroker.sendMessage(message);

    } catch (CMSException& e) {
        e.printStackTrace();
    }

    // Simple text message
    m_IfacomMessageBroker.sendMessage(text);

    long long startTime = System::currentTimeMillis();
    long long endTime = System::currentTimeMillis();
    double totalTime = (double)(endTime - startTime) / 1000.0;

    // Close the connection
    m_IfacomMessageBroker.close();

    //ui->label->setText(QString::fromStdString(text));


    // To Do at the end
    //activemq::library::ActiveMQCPP::shutdownLibrary();
    }



//***************** Receive Message  *****************************************************

void MainWindow::onMessage(const Message* message) {

        try {
            const TextMessage* textMessage = dynamic_cast<const TextMessage*> (message);
            string text = "";

            if (textMessage != NULL) {
                text = textMessage->getText();
            } else {
                text = "NOT A TEXTMESSAGE!";
            }

            //printf("Message received: %s\n", text.c_str());

            //WM  get param.
            std::string msgId = message->getCMSMessageID();
            int prio = message->getCMSPriority();
            long long timestamp = message->getCMSTimestamp();


            ui->label->setText(QString::fromStdString(text));

        } catch (CMSException& e) {
            e.printStackTrace();
        }

        // Commit all messages.
        /*if (this->m_sessionTransacted) {
            m_session->commit();
        }

        // No matter what, tag the count down latch until done.
        m_doneLatch.countDown();*/
    }

IfacomAmqReceiver.h

#ifndef _IfacomAmqReceiver_h
#define _IfacomAmqReceiver_h
#include <activemq/library/ActiveMQCPP.h>
#include <decaf/lang/Thread.h>
#include <decaf/lang/Runnable.h>
#include <decaf/util/concurrent/CountDownLatch.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/System.h>
#include <activemq/core/ActiveMQConnectionFactory.h>
#include <activemq/util/Config.h>
#include <cms/Connection.h>
#include <cms/Session.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/MapMessage.h>
#include <cms/ExceptionListener.h>
#include <cms/MessageListener.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <memory>

using namespace activemq::core;
using namespace decaf::util::concurrent;
using namespace decaf::util;
using namespace decaf::lang;
using namespace cms;

class IfacomAmqReceiver : public ExceptionListener, public MessageListener{


    private:

    CountDownLatch m_latch;
    CountDownLatch m_doneLatch;
    Connection* m_connection;
    Session* m_session;
    Destination* m_destination;
    MessageConsumer* m_consumer;
    MessageProducer* m_producer;
    std::auto_ptr<TextMessage> m_message;
    long m_waitMillis;
    bool m_useTopic;
    bool m_sessionTransacted;
    std::string m_brokerURI;
    std::string m_destName;
    DeliveryMode m_message_delivery_mode;
    int m_message_priority;
    //IfacomAmqReceiver(const IfacomAmqReceiver&);
    //IfacomAmqReceiver& operator=(const IfacomAmqReceiver&);

    public:

    IfacomAmqReceiver(const std::string&, int, bool, bool, const std::string&, int);
    virtual ~IfacomAmqReceiver();
    void close();
    void waitUntilReady() ;
    void cleanup();
    // MM
    void createConnection();
    void createSession();
    void createDestination();
    void createConsumer();
    void initConnection();

    void onMessage(const Message*);
    MessageConsumer* getConsumer();

    // If something bad happens you see it here as this class is also been
    // registered as an ExceptionListener with the connection.
    void onException(const CMSException&);

};

#endif

IfacomAmqReceiver.cpp

#include <activemq/library/ActiveMQCPP.h>
#include <decaf/lang/Thread.h>
#include <decaf/lang/Runnable.h>
#include <decaf/util/concurrent/CountDownLatch.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/System.h>
#include <activemq/core/ActiveMQConnectionFactory.h>
#include <activemq/util/Config.h>
#include <cms/Connection.h>
#include <cms/Session.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/MapMessage.h>
#include <cms/ExceptionListener.h>
#include <cms/MessageListener.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <memory>
#include "IfacomAmqReceiver.h"

using namespace activemq::core;
using namespace decaf::util::concurrent;
using namespace decaf::util;
using namespace decaf::lang;
using namespace cms;
using namespace std;


IfacomAmqReceiver::IfacomAmqReceiver(const std::string& brokerURI, int numMessages, bool useTopic = false, bool sessionTransacted = false, const std::string& destName = "IFACOM-CMS", int waitMillis = 1000) :
        m_latch(1),
        m_doneLatch(numMessages),
        m_connection(NULL),
        m_session(NULL),
        m_destination(NULL),
        m_consumer(NULL),
        m_waitMillis(waitMillis),
        m_useTopic(useTopic),
        m_sessionTransacted(sessionTransacted),
        m_destName(destName),
        m_brokerURI(brokerURI) {
    }

     IfacomAmqReceiver::~IfacomAmqReceiver() {
        cleanup();
    }

    void IfacomAmqReceiver::close() {
        this->cleanup();
    }

    void IfacomAmqReceiver::waitUntilReady() {
        m_latch.await();
    }
    //------ Init connexion ---------------
    void IfacomAmqReceiver::createConnection()
    {
        // Create a ConnectionFactory
        auto_ptr<ConnectionFactory> connectionFactory(ConnectionFactory::createCMSConnectionFactory(m_brokerURI));

        // Create a Connection
        m_connection = connectionFactory->createConnection();
        m_connection->start();
        m_connection->setExceptionListener(this);
    }

    void IfacomAmqReceiver::createSession()
    {
        // Create a Session
        if (this->m_sessionTransacted == true) {
            m_session = m_connection->createSession(Session::SESSION_TRANSACTED);
        } else {
            m_session = m_connection->createSession(Session::AUTO_ACKNOWLEDGE);
        }
    }

    void IfacomAmqReceiver::createDestination()
    {
        // Create the destination (Topic or Queue)
        if (m_useTopic) {
            m_destination = m_session->createTopic(m_destName);
        } else {
            m_destination = m_session->createQueue(m_destName);
        }
    }

    void IfacomAmqReceiver::createConsumer()
    {
        m_consumer = m_session->createConsumer(m_destination);
        //m_consumer->setMessageListener(this);
    }

    void IfacomAmqReceiver::initConnection() {

        try {

            createConnection();

            // Create the session
            createSession();

            // Create the destination (Topic or Queue)
            createDestination();

            // Create a MessageConsumer from the Session to the Topic or Queue
            createConsumer();

            // Indicate we are ready for messages.
            m_latch.countDown();

            // Wait while asynchronous messages come in.
            m_doneLatch.await(m_waitMillis);

        } catch (CMSException& e) {
            // Indicate we are ready for messages.
            //latch.countDown();
            e.printStackTrace();
        }
    }

//------ Get the message ---------------

        // Called from the consumer since this class is a registered MessageListener.
        void IfacomAmqReceiver::onMessage(const Message* message) {}

//--------------------------------------------------

    // If something bad happens you see it here as this class is also been
    // registered as an ExceptionListener with the connection.
    void IfacomAmqReceiver::onException(const CMSException& ex AMQCPP_UNUSED) {
        printf("CMS Exception occurred.  Shutting down client.\n");
        ex.printStackTrace();
        exit(1);
    }



    void IfacomAmqReceiver::cleanup() {
        if (m_connection != NULL) {
            try {
                m_connection->close();
            } catch (cms::CMSException& ex) {
                ex.printStackTrace();
            }
        }

        // Destroy resources.
        try {
            delete m_destination;
            m_destination = NULL;
            delete m_consumer;
            m_consumer = NULL;
            delete m_session;
            m_session = NULL;
            delete m_connection;
            m_connection = NULL;
        } catch (CMSException& e) {
            e.printStackTrace();
        }
    }


    MessageConsumer* IfacomAmqReceiver::getConsumer()
    {
        return m_consumer;
    }

IfacomAmqSender.h

#ifndef _IfacomAmqSender_h
#define _IfacomAmqSender_h
#include <activemq/library/ActiveMQCPP.h>
#include <decaf/lang/Thread.h>
#include <decaf/lang/Runnable.h>
#include <decaf/util/concurrent/CountDownLatch.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/System.h>
#include <activemq/core/ActiveMQConnectionFactory.h>
#include <activemq/util/Config.h>
#include <cms/Connection.h>
#include <cms/Session.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/MapMessage.h>
#include <cms/ExceptionListener.h>
#include <cms/MessageListener.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <memory>

using namespace activemq::core;
using namespace decaf::util::concurrent;
using namespace decaf::util;
using namespace decaf::lang;
using namespace cms;


 class IfacomAmqSender : public ExceptionListener{

private:

    CountDownLatch m_latch;
    CountDownLatch m_doneLatch;
    Connection* m_connection;
    Session* m_session;
    Destination* m_destination;
    MessageConsumer* m_consumer;
    MessageProducer* m_producer;
    std::auto_ptr<TextMessage> m_message;
    long m_waitMillis;
    bool m_useTopic;
    bool m_sessionTransacted;
    std::string m_brokerURI;
    std::string m_destName;
    DeliveryMode m_message_delivery_mode;
    int m_message_priority;

    IfacomAmqSender(const IfacomAmqSender&);
    IfacomAmqSender& operator=(const IfacomAmqSender&);

public:

    IfacomAmqSender(const std::string&, int, bool, bool, const std::string&, int);
    IfacomAmqSender(const std::string&, bool, bool, const std::string&);

    virtual ~IfacomAmqSender();
    void close();
    void waitUntilReady();
    void cleanup();

    // KH
    void createConnection();
    void createSession();
    void createDestination();
    void createProducer();
    void initConnection();

    virtual void sendMessage(std::string);

    // Send a ActiveMQ Message
    virtual void sendMessage(std::auto_ptr<TextMessage>);


//--------------------------------------------------

    // If something bad happens you see it here as this class is also been
    // registered as an ExceptionListener with the connection.
    virtual void onException(const CMSException&) ;

    // Message Priority (0:Lowest - 9:Highest)
    void setPriority(int);
    int getPriority();

    // Message Delivery Mode
    void setDeliveryMode(DeliveryMode);
    DeliveryMode getDeliveryMode();

    Session* getSession();

};
#endif

IfacomAmqSender.cpp

#include <activemq/library/ActiveMQCPP.h>
#include <decaf/lang/Thread.h>
#include <decaf/lang/Runnable.h>
#include <decaf/util/concurrent/CountDownLatch.h>
#include <decaf/lang/Integer.h>
#include <decaf/lang/Long.h>
#include <decaf/lang/System.h>
#include <activemq/core/ActiveMQConnectionFactory.h>
#include <activemq/util/Config.h>
#include <cms/Connection.h>
#include <cms/Session.h>
#include <cms/TextMessage.h>
#include <cms/BytesMessage.h>
#include <cms/MapMessage.h>
#include <cms/ExceptionListener.h>
#include <cms/MessageListener.h>
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
#include <memory>
#include "IfacomAmqSender.h"

using namespace activemq::core;
using namespace decaf::util::concurrent;
using namespace decaf::util;
using namespace decaf::lang;
using namespace cms;
using namespace std;






   IfacomAmqSender::IfacomAmqSender(const std::string& brokerURI, int numMessages, bool useTopic = false, bool sessionTransacted = false, const std::string& destName = "IFACOM-CMS", int waitMillis = 1000) :
        m_latch(1),
        m_doneLatch(numMessages),
        m_connection(NULL),
        m_session(NULL),
        m_destination(NULL),
        m_consumer(NULL),
        m_waitMillis(waitMillis),
        m_useTopic(useTopic),
        m_sessionTransacted(sessionTransacted),
        m_destName(destName),
        m_brokerURI(brokerURI) {
    }

    IfacomAmqSender::IfacomAmqSender(const std::string& brokerURI, bool useTopic = false, bool sessionTransacted = false, const std::string& destName = "IFACOM-CMS") :
        m_latch(1),
        m_doneLatch(1),
        m_connection(NULL),
        m_session(NULL),
        m_destination(NULL),
        m_consumer(NULL),
        m_waitMillis(1000),
        m_useTopic(useTopic),
        m_sessionTransacted(sessionTransacted),
        m_destName(destName),
        m_brokerURI(brokerURI) {
    }


     IfacomAmqSender::~IfacomAmqSender() {
        cleanup();
    }

    void IfacomAmqSender::close() {
        this->cleanup();
    }

    void IfacomAmqSender::waitUntilReady() {
        m_latch.await();
    }

//------ Init connexion ---------------

    void IfacomAmqSender::createConnection()
    {
        // Create a ConnectionFactory
        auto_ptr<ConnectionFactory> connectionFactory(ConnectionFactory::createCMSConnectionFactory(m_brokerURI));

        // Create a Connection
        m_connection = connectionFactory->createConnection();
        m_connection->start();
        m_connection->setExceptionListener(this);
    }

    void IfacomAmqSender::createSession()
    {
        // Create a Session
        if (this->m_sessionTransacted == true) {
            m_session = m_connection->createSession(Session::SESSION_TRANSACTED);
        } else {
            m_session = m_connection->createSession(Session::AUTO_ACKNOWLEDGE);
        }
    }

    void IfacomAmqSender::createDestination()
    {
        // Create the destination (Topic or Queue)
        if (m_useTopic) {
            m_destination = m_session->createTopic(m_destName);
        } else {
            m_destination = m_session->createQueue(m_destName);
        }
    }

    void IfacomAmqSender::createProducer()
    {
        m_producer = m_session->createProducer(m_destination);
        m_producer->setDeliveryMode(DeliveryMode::NON_PERSISTENT);
    }

    void IfacomAmqSender::initConnection() {

        try {

            createConnection();

            // Create the session
            createSession();

            // Create the destination (Topic or Queue)
            createDestination();

            // Create a MessageProducer from the Session to the Topic or Queue
            createProducer();
            m_producer->setDeliveryMode(DeliveryMode::NON_PERSISTENT);

            // Indicate we are ready for messages.
            m_latch.countDown();

            // Wait while asynchronous messages come in.
            m_doneLatch.await(m_waitMillis);

        } catch (CMSException& e) {
            // Indicate we are ready for messages.
            //latch.countDown();
            e.printStackTrace();
        }
    }


    void IfacomAmqSender::sendMessage(string text) {
            try {

        std::auto_ptr<TextMessage> message(m_session->createTextMessage(text));
            // to set a property
            ////message->setIntProperty("Integer", ix);
        m_producer->send(message.get());
        message->setCMSTimestamp(System::currentTimeMillis());

        } catch (CMSException& e) {
            e.printStackTrace();
        }
    }


    // Send a ActiveMQ Message
    void IfacomAmqSender::sendMessage(std::auto_ptr<TextMessage> amq_message) {
        try {

            amq_message->setCMSTimestamp(System::currentTimeMillis());
            m_producer->send(amq_message.get());

        } catch (CMSException& e) {
            e.printStackTrace();
        }
    }

//--------------------------------------------------

    // If something bad happens you see it here as this class is also been
    // registered as an ExceptionListener with the connection.
    void IfacomAmqSender::onException(const CMSException& ex AMQCPP_UNUSED) {
        printf("CMS Exception occurred.  Shutting down client.\n");
        ex.printStackTrace();
        exit(1);
    }

    // Message Priority (0:Lowest - 9:Highest)
    void IfacomAmqSender::setPriority(int priority){m_message_priority = priority;}
    int IfacomAmqSender::getPriority(){return m_message_priority;}

    // Message Delivery Mode
    void IfacomAmqSender::setDeliveryMode(DeliveryMode delivery_mode){m_message_delivery_mode = delivery_mode;}
    DeliveryMode IfacomAmqSender::getDeliveryMode(){return m_message_delivery_mode;}

    Session* IfacomAmqSender::getSession()
    {
        return m_session;
    }


    void IfacomAmqSender::cleanup() {
        if (m_connection != NULL) {
            try {
                m_connection->close();
            } catch (cms::CMSException& ex) {
                ex.printStackTrace();
            }
        }

        // Destroy resources.
        try {
            delete m_destination;
            m_destination = NULL;
            delete m_consumer;
            m_consumer = NULL;
            delete m_session;
            m_session = NULL;
            delete m_connection;
            m_connection = NULL;
        } catch (CMSException& e) {
            e.printStackTrace();
        }
    }

的main.cpp

#include "ifacomamqsender.h"
#include "mainwindow.h"
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    MainWindow w;
    w.show();

    return a.exec();
}

，错误是：

Error   29  error C2512: 'IfacomAmqSender' : no appropriate default constructor available       42  1   GUI-CMS

Answer 1

我没有在IfacomAmqSender对象的定义中看到默认构造函数，但是在MainWindow中有一个它的实例。

Answer 2

在MainWindow中，您有一个名为m_IfacomMessageBroker的成员变量IfacomAmqSender。此类没有默认构造函数，因此必须在MainWindow的初始化列表中调用其中一个构造函数。

你没有这样做，所以编译器假设你想调用默认的construtor，并注意到没有一个，所以你得到错误。没有默认构造函数的原因是因为您已经创建了自己的构造函数，因此编译器生成的默认值不存在。因此，如果您需要默认构造函数，则需要手动创建它。

Answer 3

如果我知道并且我这样做，如果程序员正在定义构造函数，则默认构造函数不可用。你已经完成了，所以没有默认的构造函数，只有你声明的构造函数。

Answer 4

你有这条线。

    IfacomAmqSender m_IfacomMessageBroker;

这是试图调用no arg构造函数，但你没有。

你有：

IfacomAmqSender(const std::string&, int, bool, bool, const std::string&, int);
IfacomAmqSender(const std::string&, bool, bool, const std::string&);

......并且需要：

IfacomAmqSender();

...或者您需要指定默认值。

Answer 5

没有默认构造函数可用于指定的类，结构或联合。如果未提供用户定义的构造函数，则编译器将提供默认构造函数。如果提供的构造函数采用非void参数，并且您希望允许在不使用参数的情况下创建类，则还必须提供默认构造函数。默认构造函数可以是具有所有参数的默认值的构造函数。

更多信息请参阅：

http://msdn.microsoft.com/en-us/library/9zkz8dx6.aspx

默认构造函数出错

5 个答案: