C ++ Struct определяет передачу данных. Простой ответ, я уверен

Question

Я уверен, что это очень простое исправление, и я чувствую себя глупо, спрашивая об этом, но здесь это идет

Мне нужна помощь со структурой и передачей информации из функции сбора в функцию сохранения или установки, а затем для повторной передачи в другую функцию для дальнейшего использования.

По сути, это выглядит так, чтобы начать. Я просто добавлю короткие фрагменты кода. Все может быть предоставлено, если вы хотели бы видеть это.

Сейчас я просто ищу правильный способ передачи структурированных данных из функций get .... в set .....

struct printype
{   
    char dots[8][15];
    int unknown15;          //  can have values of 0..127
    string serial11_14;     //  8 characters 00000000...99999999
    int year8;              //  without century, 0..99
    int month7;             //  1..12
    int day6;               //  1..31       
    int hour5;              //  0..23       
    int minute2;            //  0..59
};  
int getunknown15();     // prototypes    
int setunknown15(int);

тогда у нас есть простое основное.

int main()
{
    printype pt;
    pt.unknown15=getunknown15();
    pt.unknown15=setunknown15(12);
    pt.serial11_14=getserial11_14();
    pt.serial11_14=setserial11_14("12345678");
    pt.year8=getyear8();
    pt.year8=setyear8(44);
    pt.month7=getmonth7();
    pt.month7=setmonth7(11);
    pt.day6=getday6();
    pt.day6=setday6(12);
    pt.hour5=gethour5();
    pt.hour5=sethour5(12);
    pt.minute2=getminute2();
    pt.minute2=setminute2(23);
    cout <<"-----------------------------------------------------"<<endl;
    cout <<" Let's Get Started"<<endl;
    cout <<"-----------------------------------------------------"<<endl;
    setup(pt.dots);                         // sets up the array
    dpinfo(pt);                             // prints out the final array
    ftarray(pt);
    spar(pt.dots);
    darray(pt.dots);
}

и, наконец, функции массива get и set.

int getunknown15()
{   
    printype tem;
    cout <<"-----------------------------------------------------"<<endl;
    cout <<" Enter the Unkown Variable (0-127):  ";  
    cin  >>tem.unknown15;
    cout <<"-----------------------------------------------------"<<endl;
    return tem.unknown15;
}

следующий

int setunknown15(int tem)
{
    printype pp;


    if (tem>127||tem<0)
    {
        cout << "Error" << endl;
        return 0;
    }
    else
    {
        pp.unknown15 = tem;
        return pp.unknown15;
    }
}

Я надеюсь, что это не слишком много, чтобы читать и понимать

Во всяком случае, я знаю, что это очень простой ответ, но мой мозг просто не работает прямо сейчас.

Answer 1

Пожалуйста, используйте следующий доступ к вашим полям (по ссылке):

struct printype *myPtr = new printype;
myPtr->day6 = 43;

Когда вы используете указатель вместо обычной переменной, вы должны использовать -> вместо.чтобы получить доступ к вашим полям.

Answer 2

Я знаю, что это довольно старое, но я подумал, что стоит попробовать, так как вы используете C ++, и похоже, что вы пытаетесь использовать некоторые OO-практики (я думаю), вам не нужно начинать сструктура, даже если принципы ОО могут применяться с их использованием, хотя и не так элегантно.

вы можете определить свой заголовочный файл класса как таковой.

#ifndef PRINTYPE_H
#define PRINTYPE_H

#include <string>
using namespace std;

class printype
{
    private: // we always want to declare our member fields private for safety/managements reasons, no one will be able to access them outside.

        char dots[8][15];
        int unknown15;          //  can have values of 0..127
        string serial11_14;     //  8 characters 00000000...99999999
        int year8;              //  without century, 0..99
        int month7;             //  1..12
        int day6;               //  1..31       
        int hour5;              //  0..23       
        int minute2;            //  0..59

        void init(); // This is the method we use to initialize our starting state.

    public: // This is our public methods, how people deal with/get/set our state.
        printype(); // This is our default constructor
        printype(const printype& print_type); // This our copy constructor
        virtual ~printype(); // This is our destructor, its virtual, making safer for inheritance.


        // This is our setters/getters
        void setUnknown(int unknown);
        int getUnknown();                

        void setYear(int year);                    
        int getYear();

        void setMonth(int mont);
        int getMonth();

        // and well you get the idea, you can add more methods.
};  

#endif  

и сопутствующий исходный файл классас вашей реализацией функций

printype::printype() 
{
    this->init(); // Initialize all your vatiables, safer to just define a function to this.
}

printype::printype(const printype& orig)  // copy constructor
{
    this->setUknown(orig.getUnknown());
    this->setDay(orig.getDay());
    this->setDots(orig.getDots());     
    // you get the idea ...    
}

printype::~printype() 
{
    // Have anything you need to do before destroying the object.
}

void printype::init()
{
    this->setUnknwon(0);
    this->setyear(0);
    this->setMonth(1);
    char dots[8][15] = {'\0'};
    this->setDots(dots);

    // you get the idea, you want to initialize all your variables since, for the most part they initially hold garbage.
}

void printype::setUnknown(int unknown)
{
    if (unknown >= 0 && unknown < 127)
        this->unknown15 = unknown;
    else
        error("Expecting unknown to be between 0 and 127"); // error should probably print the error and/or exit(-1) up to u
}

int printype::setYear(int year) 
{
    if (year >= 1 && year <= 99)
        this->year8 = year;
    else
        error("Expecting year between 0 and 99"); // you may want to implement an error function!   
}
int printype::getYear()
{
    return this->year8;
}

void printype::setDots(char dots[8][15])
{
    // you may want to do some verifications
    memcpy(this->dots, dots, sizeof(dots));
}

void printype::setDots(char **dots) // this is a bit unsafe, use at your own risk.
{        
    if (dots)
    {
        unsigned int index = 0;
        for (index = 0; index < 8; index++)
            if (dots[index])
                memcpy(this->dots[index], dots[index], 15);
            else
                error("dots required pointer ...");
    }
    else
        error("dots required pointer ...");
}


char **getDots() // We will be returning a copy, we don't want the internal state to be affected, from outside, by using reference or pointers.
{
    char **dots = new char*[8];
    unsigned int index = 0;
    for (index = 0; index < 8; index++)
    {
        dots[index] = new char[15];
        memcpy(dots[index], this->dots[index], 15);
    }
    return dots;        
}

// and well you get the idea ...

для использования вашего класса

printype *print_type_p = new print_type();
// or 
printype pront_type_p();

// use the different public method to update the internal state.
print_type_p->setYear(3);
// or
print_type.setYear(3);
print_type_p->getYear();
// and so on.

Answer 3

Редактировать: Как указано в StilesCrisis, отправлять struct как параметр в этом случае довольно глупо.лучше использовать константную ссылку.

Ну, я не уверен, правильно ли я понимаю ваш вопрос.Вы можете просто отправить struct в другую функцию как параметр или как указатель.

например:

void SetStruct(const printype& var);
printype GetStruct();

Это то, что вы ищете?