Parameterübergabe const char

#1
Hallo,

ich habe dieses Programm geschrieben:

C++:
#include "../include/HyqcmqprHandler.h"

extern "C"
{
#include <stdio.h>
#include <string.h>
}

#include <TCGenUtils.hpp>

#include "Os390/Os390Base/include/IMQSspSvcStdPar.h"

#include "../include/IMQTimeConsumedByExtFctsRecorder.h"

//----------------------------------------------------------------------------
#pragma variable(empty, NORENT)
static const char empty[] = "";

//----------------------------------------------------------------------------
// struct 'HyqcmqprHandler::HyqcmqprParms'
//----------------------------------------------------------------------------
const char HyqcmqprHandler::HyqcmqprParms::validEyeCatcher[
    sizeof(HyqcmqprHandler::HyqcmqprParms::m_eyeCatcher)] =
        { 'H', 'Y', 'Q', 'C', 'M', 'Q', 'P', 'R' };

const char HyqcmqprHandler::HyqcmqprParms::version_1_0[
    sizeof(HyqcmqprHandler::HyqcmqprParms::m_version)] =
        { '0', '1', '0', '0' };

//----------------------------------------------------------------------------
inline
HyqcmqprHandler::HyqcmqprParms::HyqcmqprParms(
    char * hyqcmqprQueue,
    char * msg,
    int msgLen)
    throw()

{
    memcpy(m_eyeCatcher, validEyeCatcher, sizeof(m_eyeCatcher));
    memcpy(m_version, version_1_0, sizeof(m_version));

    memcpy(m_mqprQueue, &hyqcmqprQueue, sizeof(m_mqprQueue));

    char * myMsgPtr = * msg;
    memcpy(m_mqprMessageP, &myMsgPtr, sizeof(m_mqprMessageP));

    char * myMqmrPtr = 0;
    memcpy(m_mqprMessageP, &myMqmrPtr, sizeof(m_mqmrMessageP));

    int _msgLen = msgLen;
    memcpy(m_mqprMessageL, &_msgLen, sizeof(m_mqprMessageL));

    memset(m_mqprTargetEntity, ' ', sizeof(m_mqmrTargetEntity));

    TC_TRACE_LEAVE(SRV_CONT_TRC_GRP);
    return;
}

//----------------------------------------------------------------------------
// class 'HyqcmqprHandler'
//----------------------------------------------------------------------------
IMQSspServiceBase::SspFunction
    HyqcmqprHandler::hyqcmqprHandlerFct("CSF-MQ-Proxy", "HYQCMQPR");
//----------------------------------------------------------------------------
const char HyqcmqprHandler::_sendFctName[] =
    "HyqcmqprHandler::send";
//----------------------------------------------------------------------------
void
HyqcmqprHandler::send(
    char * hyqcmqprQueue,
    char * msg,
    int msgLen)
    throw()

{

    IMQSspSvcStdPar::SspSvcStdPar * svcStdPar =
        IMQSspSvcStdPar::getSingleton().sspSvcStdPar();

    HyqcmqprParms HyqcmqprHandlerParms(
        hyqcmqprQueue,
        msg,
        msgLen);
    
    HyqcmqprParms * hyqcmqprParmsPtr = &hyqcmqprHandlerParms;
    HyqcmqprParms * _hyqcmqprHandlerParmsPtr =
        (HyqcmqprParms *)(((int)hyqcmqprHandlerParmsPtr) | 0x80000000);

    {
        IMQTimeConsumedByExtFctsRecorder_RECORD(hyqcmqprHandlerFct);

        hyqcmqprHandlerFct(
            svcStdPar,
            _hyqcmqprHandlerParmsPtr);
    }

    if (IMQSspSvcStdPar::getSingleton().rc1() == IMQSspSvcStdPar::FAILED)
    {
        throw EBCLibFctErrExcept(SRV_CONT_TRC_GRP,
                    _sendFctName,
                    hyqcmqprHandlerFct, 0, 0, 0,
                    IMQSspSvcStdPar::getSingleton()._rc1(),
                    0,
                    __FILE__, __LINE__);
    }

    TC_TRACE_LEAVE(SRV_CONT_TRC_GRP);
    return;
}
und die dazugehörige Headerdatei:

C++:
#include "ErrBase/include/EBExcept.hpp"

#include "Os390/Os390Base/include/IMQSspServiceBase.h"

#include "../include/IMQSrvContTrace.h"

class HyqcmqprHandler
{
    struct HyqcmqprParms
    {
        
        HyqcmqprParms(
            char * hyqcmqprQueue,
            char * msg,
            int msgLen)
            throw();

        
        // Filler                PIC X(8) VALUE 'HYQCMQPR'.
        char m_eyeCatcher[8];

        //
        // values valid for 'm_eyeCatcher'
        //
#pragma variable(HyqcmqprHandler::HyqcmqprParms:: \
            validEyeCatcher, NORENT)
            static const char validEyeCatcher[];

        // Filler                PIC X(4) VALUE '0100'.
        char m_version[4];

        //
        // values valid for 'm_version'
        //
#pragma variable(HyqcmqprHandler::HyqcmqprParms:: \
            version_1_0, NORENT)
            static const char version_1_0[];


        // MQPR-QueueMgr            PIC X(48) VALUE spaces.   
        char m_mqprQueueMgr[48];

        // MQPR-Queue                PIC X(48) VALUE spaces.
        char m_mqprQueue[48];

        // MQPR-ReplyQueue            PIC X(48) VALUE spaces.
        char m_mqprReplyQueue[48];

        // MQPR-Message-p            POINTER VALUE NULL.
        char m _mqprMessageP[sizeof(void *)];

        // MQPR-Message-l            PIC S9(8) COMP-5 VALUE 0.
        char m_mqprMessageL[sizeof(int)];

        // MQPR-MessageId             PIC X(24) VALUE LOW-VALUES.
        char m_messageId[24];

        // MQPR-CorrelId             PIC X(24) VALUE LOW-VALUES.
        char m_correlId[24];

        // MQPR-CommitScope            PIC S9(4) COMP-5 VALUE 0.
        char m_mqprCommitScope[sizeof(int)];

        // MQPR-Format                PIC S9(4) COMP-5 VALUE 0.
        char m_mqprFormat[sizeof(int)];

        // MQPR-Persistency            PIC S9(4) COMP-5 VALUE 0.
        char m_mqprPersistency[sizeof(int)];

        // MQPR- Priority            PIC S9(4) COMP-5 VALUE 0.
        char m_mqprPriority[sizeof(int)];
    
        // MQPR-Expiry                PIC S9(4) COMP-5 VALUE 0.
        char m_mqprExpiry[sizeof(int)];

        // MQPR-TargetEntity            PIC X(3) VALUE ' '.
        char m_mqprTargetEntity[3];

        // MQPR-FILLER                PIC X(80) VALUE LOW-VALUES.
        char m_reserved1[80];

    };

    static IMQSspServiceBase::SspFunction hyqcmqprHandlerFct;

#pragma variable(HyqcmqprHandler:: \
        _sendFctName, NORENT)
        static const char _sendFctName[];

};
Ich möchte damit ein Modul in COBOL aufrufen. Jedoch habe ich ein Problem mit den Parametern. Wenn ich aus einer anderen Klasse heraus obige Klasse aufrufen, wie muss beim Aufruf die Parameter mitgeben? Und gibt es generelle Verbesserungsvorschläge?
 

AGGROStar1991

Well-Known Member
c-b Experte
#2
Soll das C++ sein? Welcher Sprachstandard? Denn dann solltest du statt "C im C++-Compiler" versuchen wirkliches C++ zu schreiben. Keine C-Header , keine C-Strings außer wo für die COBOL-Interaktion unbedingt nötig, nur so viele pragmas wie unbedingt nötig und vielleicht generell mal durch einen Stylechecker jagen(ich nehme an HICPP, cppcoreguidelines uvm. finden da eine Menge zu meckern),
 
Oben