Bad design di codice c ++? [chiuso]

Question

Bad design di codice c ++? [chiuso]

#1 da (9 voti)

3

Questo mi disturba da molto tempo. Mi sento come se stessi facendo degli errori sul design del codice relativo alla performance. Non ho mai avuto nessun insegnante per indicare i miei errori, quindi è difficile per me farlo in pratica.

Il codice riguarda un server che sto creando. Ho diviso il programma in alcune classi principali come "Receiver", "Sender", Data_Handler "," Socket "... (perché pensavo che fosse più organizzato). Uso l'allocazione dinamica della memoria per crearli su main.cpp (Cosa dovrebbe essere negativo per le prestazioni ...?). Quindi passo le classi con i puntatori alle altre classi per usare le sue funzioni e le variabili che mi servono. Dovrei farli classi statiche? Dove devo cambiare il metodo del mio codice?

Main.cpp

#include "UserData.h"
#include "DataHandler.h"
#include "Sender.h"
#include "Socket.h"
#include "Receiver.h"


int main(int argc, char **argv)
{
    bool State = true;

    Socket *socket = new Socket;
    UserData *userdata = new UserData(socket);
    Receiver *receiver = new Receiver(socket, userdata);
    DataHandler *datahandler = new DataHandler(socket, userdata, receiver);
    Sender *sender = new Sender(socket, userdata, datahandler);

    while (State)
    {
        /* - - - - - - - - -Receive Data- - - - - - - - - - - */
        int Activity = SDLNet_CheckSockets(socket->Socket_Set, 0);
        if (Activity > 0)
        {
            /*      ---    Accept     ---    */
            while (SDLNet_SocketReady(socket->s_tcp))
            {
                --Activity;
                userdata->Accept();
                if (userdata->Who == Max_Users)userdata->Data_Status = 3;
                datahandler->TCP_Handler();
                sender->Send();
                if (userdata->Data_Status == 3)userdata->disconnect();

            }
            /*       ---     UDP      ---     */
            while (SDLNet_SocketReady(socket->s_udp))
            {
                --Activity;
                receiver->udp();
                datahandler->UDP_Handler();
                sender->Send();
            }
            /*     ---    TCP     ---    */
            unsigned int i = 0;
            while (Activity)
            {
                if (userdata->Check_TCP(i))
                {
                    --Activity;

                    //Data Flow
                    receiver->tcp();
                    datahandler->TCP_Handler();
                    sender->Send();

                    //Disconnect User
                    if (userdata->Data_Status){ i--; userdata->disconnect(); }
                }
                i++;
            }
        }
    }

    delete receiver;
    delete sender;
    delete datahandler;
    delete userdata;
    delete socket;
    return EXIT_SUCCESS;
}

DataHandler.h (una classe casuale)

#pragma once
#include <vector>
#include <iostream>
#include <sstream>
#include "Socket.h"
#include "UserData.h"
#include "Receiver.h"
#include "Constants.h"



class DataHandler
{
public:
    DataHandler::DataHandler(Socket *socket_p, UserData *userdata_p, Receiver *receiver_p);
    void UDP_Handler();
    void TCP_Handler();
    DataHandler::~DataHandler();

    int For;
    bool How;
    std::string What;

private:
    Socket *socket;
    UserData *userdata;
    Receiver *receiver;

    std::string data_part;
    std::istringstream divider;

    //TCP
    void Accepted();
    void Full();
    void Disconnected();
    void Login();

    //UDP
    void Confirm();
};

object-oriented code-quality coding-style c++ performance

posta Andre Marques 26.02.2016 - 00:19

fonte

1 risposta

Leggi altre domande sui tag object-oriented code-quality coding-style c++ performance

Che cosa fai per articolare il tuo vantaggio come programmatore in un'organizzazione in cui sei un centro di costo? [chiuso] Per quali ragioni Java e C # inizializzano i dati statici su richiesta?

score 9 · Accepted Answer

Non c'è niente di intrinsecamente sbagliato in questo modello. Lo uso da solo in alcuni punti.

L'unica cosa che suggerirei davvero è di eliminare le allocazioni dinamiche, non perché avranno nel tuo caso un effetto notevole di prestazioni, ma perché è un disordine inutile che hai ricordarsi di pulire alla fine. Puoi ancora utilizzare i puntatori senza l'allocazione dinamica:

Socket socket;
UserData userdata(&socket);
Receiver receiver(&socket, &userdata);
DataHandler datahandler(&socket, &userdata, &receiver);
Sender sender(&socket, &userdata, &datahandler);

Tuttavia potrebbe essere più razionale utilizzare i riferimenti rispetto ai puntatori.

Man mano che la tua applicazione cresce, puoi prendere in considerazione l'uso di un "registro" per archiviare questi componenti che possono essere consultati e utilizzati dai loro amici.

Stai attento alle dipendenze circolari. Ed è una preoccupazione per me che passi gli stessi indicatori in più componenti. Riesci a rendere il tuo progetto "a strati" in modo da non dover passare l'istanza Socket in tutti gli altri tuoi oggetti? Sembra che UserData e Receiver debbano gestire tutte le interazioni con Socket e che DataHandler non dovrebbe essere in grado di rovinare tutto interagendo con Socket .