Style-off



  • Meistens bekommt man beim durchstöbern von Artikeln
    und sonstigen Internet Gelegenheiten, sich die Arbeit anderer anzuschauen, nur einen präparierten Code zu sehen.
    Es werden Kommentare eingefügt, Absätze gemacht und Leerzeichen eingefügt.

    Aber wie schreibt ihr wirklich euren Code? Macht ihr für euch selbst Kommentare um
    Übersicht zu behalten? Macht ihr viele Absätze, viele Tabs?
    Wie übersichtlich muss euer Code sein und was seht ihr als übersichtlich an?

    Kopiert einen Abschnitt eures derzeitigen Projekts und präsentiert ihn hier ungeschminkt.



  • Nie Tabs, Kommentare nur zum Unterteilen und für Präprozessor-Ifs, 2 Leerschläge und Allman-Einrückungsstil. Und nie Systemabhängige Dinge wie int sondern unsigned long int ;

    Header:

    //////////////////////////////////////////////////////////////////
    // File: Dateiname.Dateiendung                                  //
    //////////////////////////////////////////////////////////////////
    #ifndef Projektname_Dateiname_Dateiendung
    #define Projektname_Dateiname_Dateiendung
    //////////////////////////////////////////////////////////////////
    namespace Projektname
    {
      class Foo
      {
        private:
          unsigned long int Bar;
    
        public:
          explicit inline Foo(unsigned long int Bar) throw();
    
      };
    };
    //////////////////////////////////////////////////////////////////
    #endif //!Projektname_Dateiname_Dateiendung
    //////////////////////////////////////////////////////////////////
    

    Code:

    //////////////////////////////////////////////////////////////////
    // File: Dateiname.Dateiendung                                  //
    //////////////////////////////////////////////////////////////////
    #ifndef Projektname_Dateiname_Dateiendung
    #define Projektname_Dateiname_Dateiendung
    //////////////////////////////////////////////////////////////////
    explicit inline
    Projektname::
    Foo::
    Foo(unsigned long int Bar) throw()
    {
      this->Bar = Bar;
    };
    //////////////////////////////////////////////////////////////////
    #endif //!Projektname_Dateiname_Dateiendung
    //////////////////////////////////////////////////////////////////
    


  • Hier ein provisorischer Code ohne Auslagerung temporärer Hilfsstrukturen zur Erzeugung von Bounding Spheres basierend auf einem in Vertices vorliegenden Modell, wobei die Bounding Spheres als Baum aber linear im Speicher im vector abgelegt vorliegen: (was hässlicher Gecodetes wird sich in meinem ganzen Projekt nicht finden ^^)

    // Create first Sphere at first
    
    		struct SphereConstructElement
    		{
    			std::vector<std::size_t>		vertexIDs;
    			std::size_t						sphereID;
    			std::size_t						parentSphereID;
    
    			SphereConstructElement() {}
    			SphereConstructElement(std::vector<std::size_t> pVertexIDs, std::size_t pSphereID, std::size_t pParentSphereID)
    				: vertexIDs(pVertexIDs), sphereID(pSphereID), parentSphereID(pParentSphereID) {}
    		};
    
    		typedef std::queue<SphereConstructElement> ConstructQueue;
    
    		// Insert Parent Construct Element
    		ConstructQueue constructQueue;
    		SphereConstructElement e;
    		for(std::size_t n = 0; n < numberOfVertices_; ++n)
    			e.vertexIDs.push_back(n);
    		e.parentSphereID = -1;
    		e.sphereID = 0;
    		constructQueue.push(e);
    
    		UsualVector vec;
    		std::size_t radiusVertex;
    		CoordinateType radius;
    
    		// Insert all Spheres
    		while(!constructQueue.empty())
    		{
    			auto& currentElement = constructQueue.front();
    
    			// Find center
    			vec = UsualVector(0.f, 0.f, 0.f);
    
    			BOOST_FOREACH(auto v, currentElement.vertexIDs)
    			{
    				vec += UsualVector(	aggregatedVertices_[v].x,
    									aggregatedVertices_[v].y,
    									aggregatedVertices_[v].z);
    			}
    
    			vec /= currentElement.vertexIDs.size();
    
    			// Find biggest Distance
    			radius = 0.f;
    			BOOST_FOREACH(auto v, currentElement.vertexIDs)
    			{
    				if(aggregatedVertices_[v].x - vec.GetX() + aggregatedVertices_[v].y - vec.GetY() + aggregatedVertices_[v].z - vec.GetZ() > radius)
    				{
    					radius = aggregatedVertices_[v].x - vec.GetX() + aggregatedVertices_[v].y - vec.GetY() + aggregatedVertices_[v].z - vec.GetZ();
    					radiusVertex = v;
    				}
    			}
    
    			radius = std::sqrt(	(aggregatedVertices_[radiusVertex].x - vec.GetX()) * (aggregatedVertices_[radiusVertex].x - vec.GetX()) +
    								(aggregatedVertices_[radiusVertex].y - vec.GetY()) * (aggregatedVertices_[radiusVertex].y - vec.GetY()) +
    								(aggregatedVertices_[radiusVertex].z - vec.GetZ()) * (aggregatedVertices_[radiusVertex].z - vec.GetZ()));			
    
    			GetBoundingSphereVector(*newModel_).push_back(BoundingSphere(	vec.GetX(), vec.GetY(), vec.GetZ(), radius,
    																			currentElement.parentSphereID));
    
    			currentElement.sphereID = GetBoundingSphereVector(*newModel_).size() - 1;
    
    			// Try subdividing model by different planes
    			std::size_t planeXYSide1 = 0, planeXYSide2 = 0, planeXZSide1 = 0, planeXZSide2 = 0, planeYZSide1 = 0, planeYZSide2 = 0;
    
    			std::vector<std::size_t> left, right, top, bottom, front, back;
    
    			BOOST_FOREACH(auto v, currentElement.vertexIDs)
    			{
    				if(aggregatedVertices_[v].z < vec.GetZ())
    					front.push_back(v);
    				else
    					back.push_back(v);
    
    				if(aggregatedVertices_[v].x < vec.GetX())
    					left.push_back(v);
    				else
    					right.push_back(v);
    
    				if(aggregatedVertices_[v].y < vec.GetY())
    					bottom.push_back(v);
    				else
    					top.push_back(v);
    			}
    
    			std::size_t bestDifference = difff(front.size(), back.size());
    			std::vector<std::size_t>* usedContainer = &front;
    
    			if(difff(left.size(), right.size()) < bestDifference)
    			{
    				bestDifference = difff(left.size(), right.size());
    				usedContainer = &left;
    			}
    
    			if(difff(top.size(), bottom.size()) < bestDifference)
    			{
    				bestDifference = difff(top.size(), bottom.size());
    				usedContainer = &top;
    			}
    
    			if(usedContainer->size() > 3) // const 50 Vertices!
    			{
    				constructQueue.push(SphereConstructElement(*usedContainer, 0, currentElement.sphereID));
    
    				if(usedContainer == &front)
    					constructQueue.push(SphereConstructElement(back, 0, currentElement.sphereID));
    				if(usedContainer == &left)
    					constructQueue.push(SphereConstructElement(right, 0, currentElement.sphereID));
    				if(usedContainer == &top)
    					constructQueue.push(SphereConstructElement(bottom, 0, currentElement.sphereID));
    			}
    
    			constructQueue.pop();
    		}
    


  • EOutOfResources schrieb:

    namespace Projektname
    {
    //...
    };
    

    Das ; ist da falsch, glaube ich.



  • volkard schrieb:

    EOutOfResources schrieb:

    namespace Projektname
    {
    //...
    };
    

    Das ; ist da falsch, glaube ich.

    also visual c++ 2010 läassts durchgehen
    und wenn man man class'en und structs und enums und unions und und und damit beenden muss, wieso dann nicht auch namespaces?
    weil mans bei funktionen nicht muss?



  • ; ist doch nie falsch, es ist lediglich optional. 🤡

    Ich kann doch auch das hier schreiben:

    #include <iostream>
    int main()
    {
    std::cout << "Random";
    ;;;;;;;;;;;;;;;;;;
    return 0;;;
    ;;;
    };;;;;;;
    ;
    ;;;;
    




  • Dieser Thread wurde von Moderator/in pumuckl aus dem Forum C++ (auch C++0x) in das Forum Rund um die Programmierung verschoben.

    Im Zweifelsfall bitte auch folgende Hinweise beachten:
    C/C++ Forum :: FAQ - Sonstiges :: Wohin mit meiner Frage?

    Dieses Posting wurde automatisch erzeugt.



  • AP0LL0 schrieb:

    Aber wie schreibt ihr wirklich euren Code? Macht ihr für euch selbst Kommentare um
    Übersicht zu behalten? Macht ihr viele Absätze, viele Tabs?
    Wie übersichtlich muss euer Code sein und was seht ihr als übersichtlich an?

    Kopiert einen Abschnitt eures derzeitigen Projekts und präsentiert ihn hier ungeschminkt.

    Ich schreibe meinen Code grundsätzlich so, als ob ich ihn für jmd anderen schreibe. Weil man ja nie weiß, ob man ihn nicht doch mal aus der hand gibt. Ich gebe mir viel Mühe und verbrauche relativ viel Zeit, um meinen Code sauber zu schreiben - siehe auch das Zitat in meiner Signatur 😉

    (Das mag einer der Gründe sein warum ich mit meinen privaten Projekten meist nur sehr langsam vorankomme und sie irgendwann im Sande verlaufen. Aber das ist ein anderes Thema...)



  • Eisflamme schrieb:

    ; ist doch nie falsch, es ist lediglich optional. 🤡

    Ich kann doch auch das hier schreiben:

    #include <iostream>
    int main()
    {
    std::cout << "Random";
    ;;;;;;;;;;;;;;;;;;
    return 0;;;
    ;;;
    };;;;;;;
    ;
    ;;;;
    

    Die leere Anweisung kenne ich. Also innerhalb der Funktion kannste toben. Aber die leere Deklaration kenne ich nicht. Warum kannste ausßerhalb?



  • EOutOfResources schrieb:

    Und nie Systemabhängige Dinge wie int sondern unsigned long int ;

    Ahhhja.... Zwar sind Überläufe bei unsigned-Typen definiert, aber die Größe ist immer noch implementierungsabhängig.



  • Skym0sh0 schrieb:

    also visual c++ 2010 läassts durchgehen
    und wenn man man class'en und structs und enums und unions und und und damit beenden muss, wieso dann nicht auch namespaces?
    weil mans bei funktionen nicht muss?

    Nach Typdefinitionen muß eins. Das läßt aber keine Schlüsse dasrüber zu, ob nach Funktionsdefinitionen oder namespacees eins muß. Nichtmal, ob da eins darf.



  • AP0LL0 schrieb:

    Aber wie schreibt ihr wirklich euren Code?

    Tastatur ?

    /**************************************************************************
    #
    # Programname: 	    blabla
    # Version: 	    13.37
    # Datum:	    01.01.1909
    # Author:	    Vorname Nachname
    # Bemerkungen: 	    I'm Batman 	
    #
    **************************************************************************/
    
    #include <iostream>
    
    int blabla();
    
    int  main ()
    {
    
        // Diese Schleife macht blabla
        while(1==1)
        {
            // Noch mehr blablabla
        }
    
        if (1000 > 1)
        {
           int x = 0;                     // Variable X
           x = 9 / 0;
        }
    
        return 0;
    }
    
    //Diese Funktion macht Bla Bla
    
    int blabla()
    {
        return 9001;
    }
    


  • pumuckl schrieb:

    AP0LL0 schrieb:

    Aber wie schreibt ihr wirklich euren Code? Macht ihr für euch selbst Kommentare um
    Übersicht zu behalten? Macht ihr viele Absätze, viele Tabs?
    Wie übersichtlich muss euer Code sein und was seht ihr als übersichtlich an?

    Kopiert einen Abschnitt eures derzeitigen Projekts und präsentiert ihn hier ungeschminkt.

    Ich schreibe meinen Code grundsätzlich so, als ob ich ihn für jmd anderen schreibe. Weil man ja nie weiß, ob man ihn nicht doch mal aus der hand gibt. Ich gebe mir viel Mühe und verbrauche relativ viel Zeit, um meinen Code sauber zu schreiben - siehe auch das Zitat in meiner Signatur 😉

    (Das mag einer der Gründe sein warum ich mit meinen privaten Projekten meist nur sehr langsam vorankomme und sie irgendwann im Sande verlaufen. Aber das ist ein anderes Thema...)

    Ich fühle mit dir. Ich habe das selbe "Problem", ich benötige manchmal Tage um 300 Zeilen zu schreiben. Jedoch nehme ich es mit der offiziellen code-style Schule nicht ganz so ernst wie andere und benutze sehr viele Tabs um es relativ tabellarisch zu halten.

    #define					FDRS						__internal_read_stub_
    typedef
    						class						__internal_read_stub_
    { 
    	enum __cache_layout_enum_{
    		FDR_PACKET_CACHE,							//255 (0-244)
    		FDR_MASTER_NAME = 509						//255 (244-509)
    	};
    
    	struct __packet_layout_gen_{
    						unsigned int				_4_vers						:4,
    													_2_cmd						:2,
    													_8_len						:8,
    													_24_off						:24;
    						union						__sub_prot_data_
    						{
    							struct					__sub_prot_query_data_
    							{ unsigned int			_2_qcmd						:2,
    													_32_qopt					:32; }_34_query;
    							struct					__sub_prot_in_data_
    							{ unsigned char			_data[249];					     }_1992_in;
    							struct					__sub_prot_in_msg_
    							{ unsigned int			_32_msg						:32;
    							  unsigned char			_name[245];						 }_1992_msg;
    							struct					__sub_prot_error_
    							{ unsigned int			_32_err						:32; }_32_err;
    						}_2002_sub_data;
    	};
    	typedef											__packet_layout_gen_*		DATA_STUB;
    
    private:
    	__w64				unsigned long				_ul_fd,			//endpoint descriptor
    													_ul_dispatch;	//dispatchroutine reference
    						void						*_kp_event;		//dispatch object prt
    						char						*_pc_cache;		//object memory (base) ptr
    						SOCKADDR_IN					*_p_sa_host;	//remote-host address-drescriptior
    
    	unsigned long		static __stdcall			__fd_read_routine_(
    		__in void* );
    			 bool		static __stdcall			__icmp_probe_host_(
    		__in void* ),
    													__tcp_try_create_(
    		__in void* );
    
    }__INT_RS_;
    typedef					__INT_RS_*					FDRHANDLE;
    


  • AP0LL0 schrieb:

    ...

    *grusel*

    Da, wenn du mal etwas neueren Code aus meinem Projekt haben willst (ich hatte aber noch nicht die Güte, den für mich oder dich nochmal zu überarbeiten 😉 ):

    #include <General/Utils.h>
    #include <Compiler/Qompiler.h>
    #include <limits>
    #include <fstream>
    #include <stdexcept>
    #include <ctime>
    #include <iostream>
    
    ///time
    
    double utils::ExecutionTime()
    {
    	return clock() / (double)CLOCKS_PER_SEC;
    }
    
    ///strings
    
    //if ASCII is defined, str_t and std::string are the same and thus these functions must not be provided twice
    #if !defined(_ASCII)
    
    void utils::strings::Replace(str_t &in, char_t find, char_t replace)
    {
        for(size_t pos = 0; pos < in.size(); ++pos)
        {
            if(in[pos] == find) in[pos] = replace;
        }
    }
    
    void utils::strings::Replace(str_t &in, const str_t &find, const str_t &replace)
    {
        size_t find_pos = 0, pos = 0;    //position in the find string
    
        while(pos < in.size())
        {
            find_pos = 0;
            //check if it matches
            while (find_pos < find.size() && find[find_pos] == in[pos + find_pos]) ++find_pos;
    
            if(find_pos == find.size()) //the strings match
            {
                in.replace(pos, find.size(), replace);
                pos += replace.size();
            }
            else
            {
                ++pos;
            }
        }
    }
    
    str_t utils::strings::GetReplaced(const str_t &in, char_t find, char_t replace)
    {
        str_t ret = in;
        utils::strings::Replace(ret, find, replace);
        return ret;
    }
    
    str_t utils::strings::GetReplaced(const str_t &in, const str_t &find, const str_t &replace)
    {
        str_t ret = in;
        utils::strings::Replace(ret, find, replace);
        return ret;
    }
    
    #endif  // !defined(_ASCII)
    
    void utils::strings::Replace(std::string &in, char find, char replace)
    {
        for(size_t pos = 0; pos < in.size(); ++pos)
        {
            if(in[pos] == find) in[pos] = replace;
        }
    }
    
    void utils::strings::Replace(std::string &in, const std::string &find, const std::string &replace)
    {
        size_t find_pos = 0, pos = 0;    //position in the find string
    
        while(pos < in.size())
        {
            find_pos = 0;
            //check if it matches
            while (find_pos < find.size() && find[find_pos] == in[pos + find_pos]) ++find_pos;
    
            if(find_pos == find.size()) //the strings match
            {
                in.replace(pos, find.size(), replace);
                pos += replace.size();
            }
            else
            {
                ++pos;
            }
        }
    }
    
    std::string utils::strings::GetReplaced(const std::string &in, char find, char replace)
    {
        std::string ret = in;
        utils::strings::Replace(ret, find, replace);
        return ret;
    }
    
    std::string utils::strings::GetReplaced(const std::string &in, const std::string &find, const std::string &replace)
    {
        std::string ret = in;
        utils::strings::Replace(ret, find, replace);
        return ret;
    }
    
    void utils::strings::ConvertToLower(str_t &what)
    {
        for(size_t i = 0; i < what.size(); ++i) what[i] = tolower(what[i]);
    }
    
    size_t utils::binary::GetLeadingOnesCount(unsigned char in)   //returns the number of leading ones in binary
    {
        //optimized
    
        if((in & BIN(10000000)) == BIN(00000000)) return 0;   //starting with 0
        if((in & BIN(11000000)) == BIN(10000000)) return 1;   //the first two bits are 10
        if((in & BIN(11100000)) == BIN(11000000)) return 2;   //110
        if((in & BIN(11110000)) == BIN(11100000)) return 3;   //1110
        if((in & BIN(11111000)) == BIN(11110000)) return 4;   //etc.
        if((in & BIN(11111100)) == BIN(11111000)) return 5;
        if((in & BIN(11111110)) == BIN(11111100)) return 6;
        if(in == BIN(11111110)) return 7;
        return 8;
    }
    
    size_t utils::binary::GetLeadingZerosCount(char_t in)
    {
        int bits = sizeof(in) * 8;
        int bit_count = bits - 1;   //-1 for shifting (32 bits -> shift by 31 to get the first one)
    
        for(; bit_count >= 0; --bit_count) if((in & (1 << bit_count)) != 0) break;
        //now bit_count is at the first binary 0
    
        return bits - bit_count - 1;
    }
    
    utils::numbers::NumberType utils::numbers::GetStringNumberType(str_t in)
    {
        size_t len = in.length();
        if(len == 0) return utils::numbers::INVALID;    //nothing inside
    
        size_t pos = 0;
        bool is_positive = true, is_nonzero = false, is_float = false;
    
        //check for signs, increase pos if found and reset is_positive if necessary
        if(in[0] == _('-'))
        {
            ++pos;
            is_positive = false;
        }
        else if(in[0] == _('+'))
        {
            ++pos;
        }
    
        //check if no digit is following
        if(pos == len || !utils::IsDigit(in[pos])) return utils::numbers::INVALID;
    
        for(;pos < len; ++pos)  //loop over digits following
        {
            if(!utils::IsDigit(in[pos])) break;    //no digit, go out of the loop
    
            if(in[pos] != _('0')) is_nonzero = true;
        }
    
        if(pos < len)   //something is following
        {
            if(in[pos] == _('.') || in[pos] == _(','))  //a floating number
            {
                ++pos;
                if(pos >= len || !utils::IsDigit(in[pos])) return utils::numbers::INVALID;  //no digit following after '.' or ';'
    
                //it does not necessarily have to be a floating number,
                //first check if the digits after the point/comma are not zeros
                for(;pos < len; ++pos)  //loop over digits following
                {
                    if(!utils::IsDigit(in[pos])) break;    //no digit, break
    
                    if(in[pos] != _('0'))
                    {
                        is_float = true;
                        is_nonzero = true;  //only relevant at 0.xx or -0.xx
                    }
                }
    
                //check if something unexpected is following
                if(pos < len)   return utils::numbers::INVALID;
            }
            else    //no point or comma following, error
                return utils::numbers::INVALID;
        }
    
        //finally evaluate return value
        if(!is_nonzero) return utils::numbers::ZERO;
    
        //else
        if(is_float)
        {
            if(is_positive) return utils::numbers::FLOAT_POSITIVE;
            return utils::numbers::FLOAT_NEGATIVE;
        }
    
        if(is_positive) return utils::numbers::INTEGER_POSITIVE;
        return utils::numbers::INTEGER_NEGATIVE;
    }
    
    str_t const &utils::numbers::GetPlatformSizeTMaxString()
    {
        static str_t max_size_t_str = str_t(PLATFORM_SIZE_T_MAX_STR);
    
        return max_size_t_str;
    }
    
    ///utils::file
    
    str_t utils::file::Read(std::string name)  //no str_t, name is ASCII
    {
        static std::ifstream in;
    
        //we can open it binary because newlines are converted by encoding::FileStringToUTF() to '\n'
        in.open(name.c_str(), std::ios_base::in | std::ios_base::binary);
        if(!in.is_open())
        {
            std::string err = "Datei \"";  //TODO: translate
    		err += name;
    		err += "\" konnte nicht geoeffnet werden.\n";
    		throw std::runtime_error(err);  //PRIORITY_LOW: make a FileNotOpenedException deriving from std::Exception
        }
        std::ostringstream out;
        out << in.rdbuf();
        in.close();
        std::string tmp = out.str();
    #if defined(_TEST_PRINT_OPEN_FILE_)
        std::cout << "File: " << name << "\nEncoding: " << encoding::GetEncoding(tmp) << "\n";
    #endif  //defined(_TEST_PRINT_OPEN_FILE_)
    
        return encoding::FileStringToUTF(tmp, name);
    }
    
    void utils::file::Write(std::string name, str_t const &s)  //kein str_t, dateiname ist ANSI
    {
        static std::ofstream ostr;
        ostr.open(name.c_str());
        if(!ostr.is_open())
        {
            std::string err = "Datei \"";
    		err += name;
    		err += "\" konnte nicht geoeffnet werden.\n";
    		throw std::runtime_error(err);
        }
        ostr << encoding::UTF32To8(s);
        ostr.close();
    }
    


  • AP0LL0 schrieb:

    ...
    

    Jedoch nehme ich es mit der offiziellen code-style Schule nicht ganz so ernst wie andere und benutze sehr viele Tabs um es relativ tabellarisch zu halten.

    Ist ja Furchtbar, kommen andere damit klar ?
    Versuch es so wie wxSkip es gepostet hat.

    @wxSkip

    👍



  • Sheldor schrieb:

    AP0LL0 schrieb:

    ...
    

    Jedoch nehme ich es mit der offiziellen code-style Schule nicht ganz so ernst wie andere und benutze sehr viele Tabs um es relativ tabellarisch zu halten.

    Ist ja Furchtbar, kommen andere damit klar ?
    Versuch es so wie wxSkip es gepostet hat.

    @wxSkip

    👍

    Nein, aber muss ja auch keiner. Ich finde es immer sehr irritierend wenn Leute sich wirklich über meinen Code "beschweren" und wollen dass ich ihn ändere.
    Codestyle ist für mich eher eine persönliche Angelegenheit. Das ist für mich so als würde ich sagen dass dein Haar nicht richtig aussehen würde und du mehr wie die anderen deine Haare machen solltest, weil es so normal und konventioneller ist. (In Wirklichkeit ist das ja komplett dein Ding, und deine Ästhetik, dein Haar darf dich nur nicht in deiner Leistung einschränken).

    Ich hatte gehofft hier auch ein paar andere "eigene" Styles zu finden und mir vielleicht etwas abzuschauen. Etwas was mir gefallen hat und dir vielleicht zu Verstehen hilft wonach ich suche. Ich suche nach eigenen Style-Charakteristiken. Ein Beispiel dafür wäre der Post von EOutOfResources, der jeden Anfang und jedes ende mit durchgängigen Kommentar-Balken versehrt und bei seinen Funktions-Deklarationen pro namespace eine Zeile lässt. Es sagt ein bisschen etwas über den Programmierer aus und gibt dem Code eine persönliche Note.



  • AP0LL0 schrieb:

    ...

    Es gibt noch mehr "senkrecht-coder" wie Dich. Zur Zeit seid ihr in der totalen Minderzahl. Aber das betrifft ja nur Datendefinitionen und -Deklarationen.

    Im Hauptcode bist Du sicherlich auch waagerecht orientiert, oder?



  • @wxSkip: Was fällt mir an Deinem Code als Fremdleser zuerst ins zweifelnde Auge?
    Bitte nur beantworten, wenn Du einverstanden bist, daß der Thread abkippt in ein "Ich zeige was aus der Praxis und jemand meckert rum". Der alte "Ich zeige was aus der Praxis" ist auch schon genial. Weiß nicht, ist der nicht schon kaputt?
    Man müßte nochmal zwei neue aufmachen, die streng getrennt sind.



  • Na ja, aktuell ist das zwar nicht mehr wirklich, aber da hat sich eigentlich nicht viel geändert vom Stil her 😉

    // Main loop. "HTTP-requests" until video is loaded. (Or exception occurs)
    int YoutubeLoader::Load(const std::string& url)
    {
      using namespace std;
    
      if (!m_callback)
        throw ex::exception("No callback function given!", YTLD_ERROR_CALLBACK);
    
      Callback(YTDL_START, g_info_start.length(), g_info_start.c_str());
      try
      {
        ParseURL(url);
    
        while (1)
        {
          Callback(YTDL_THREADSTATUS, 0, 0); // If callback returns 0 loop shall end
          Socket();
          SendRequest();
          RecvResponse();
    
          switch (atoi(m_http_buf.c_str() + string("HTTP/x.x ").length()))
          {
          case 200:
            GetFlashdata();
            break;
          case 206:
            LoadVideo();
            return 0;
          case 301:
          case 302:
            ParseRedirect();
            break;
          default:
            throw ex::exception("Unknown HTTP-behavior", 
              atoi(m_http_buf.c_str() + string("HTTP/x.x ").length()));
            break;
          }
        }
      }
      // Catches exception thrown by YTDL_THREADSTATUS request
      catch (int val)
      {
        return val;
      }
    }
    

    Siehe auch: http://www.c-plusplus.net/forum/282269


Anmelden zum Antworten