C moving genomsnittet

Jag har tagit en klass i C och jag har lärt mig lite av det själv och jag tror att jag är på den punkten där jag kunde göra några enkla program (mer än bara några hundra rader av kod som bokexempel) men jag dont ha några bra idéer för vad du ska programmera. Jag började skriva kod för en textbaserad RPG men jag vill försöka att koda något mer som de faktiska programmerare som programmerar för en levande kod. Alla som arbetar på fältet har några förslag I Lounge forumet finns det några idéer. Här är några: hrm. Jag kan föreslå ett avsnitt som läggs till för projektidéer. En av de saker jag alltid kämpat med när jag lärde mig ett nytt språk är att hitta projekt som skulle testa min kunskap utan att komma före vad jag läste eller förstod. (hela tiden är det något roligt och underhållande att träna på. Något som gav mig någon form av belöning, till exempel att ha skrivit ett program som jag faktiskt kunde använda för.) En sektion där Projekt kunde lämnas in, tillsammans med svårigheter eller något sätt att veta i vilken ordning som är bäst att göra dem skulle vara en bra idé. Jag vet att det här förmodligen inte är så mycket hjälp för dig icemanfan. Men det hjälper förmodligen människor som jag, som just började C. Det här är min lista som jag gjorde. hehe. Jag fastnar på nummer 22. lolz. Kunde inte få den dumma bubbelklassen att arbeta för som 2 nätter nu. suckar. Nybörjare 1. Skriv ett program som finner fakulteten för ett tal som skrivits in av användaren. (kontrollera alla villkor) (Nybörjare). 2. Utveckla ett program för att konvertera valuta X till valuta Y och visa versa (nybörjare). 3. Skriv ett program som skriver ut följande, användaren kommer in i toppnumret: 4. Skriv ett program som skriver ut följande, användaren kommer in i bottennumret: 5. Skriv ett program som prarar ut följande triangel, användaren kommer att ange bottennumret: 6. Utveckla ett program som använder ett slumpmässigt genererat nummer för att välja 1 av 3 (eller fler) funktioner för att visa användaren. (Nybörjare) 7. Gissande spel. Skriv ett c-spel som ber användaren att gissa ett tal mellan 1 och 100. Om du gissade korrekt, kommer det att säga att du vinner. Om du är för hög eller för låg så kommer den också att låta dig veta. (Nybörjare) 8. Skapa ett program som genererar Fibonacci-serien till ett nummer n där n anges av användaren. För t. ex. Om användaren går in i 10 så kommer utsignalen att vara: 1 1 2 3 5 8 (Nybörjare) 9. Bestäm hur många av tecknen är vokaler och hur många är konsonanter i en given textrad. Avsluta också strängen när ingångskaraktären är annorlunda än alfabeten. (Nybörjare). 10. Hitta den femte roten av summan av kvadraterna för de första 100 ODD-talen bara. (Nybörjare) 11. Utför 4-bokstavsordskrämning, dvs lista alla möjliga kombinationer av 4 bokstäver i ett ord. Ex: Ordet TEST kan krypteras som TEST, TETS, TSET, TSTE, TTSE, TTES, etc. (Nybörjare) 12. Gör ett program som tillåter användaren att mata in radius, diameter eller område av cirkeln. Programmet ska sedan beräkna de andra 2 baserat på ingången. (Nybörjare) 13. LÄS en textruta och skriv ut BACKWARDS med RECURSIVE-funktionen. (Nybörjare) 14. Skriv ett program för att SWAP innehållet i 3 variabler utan att använda de tillfälliga (eller extra) variablerna. (Nybörjare) 15. Skriv ett program som vrider siffrorna i ett heltal, det vill säga 326 blir 623, etc. (Nybörjare) 16. Programmet kommer att berätta för användaren varje gång om han gissade hög eller låg. Användaren vinner spelet när antalet gissade är samma som slumpmässigt genererat nummer. (Nybörjare) 17. Skriv ett program för att simulera en enkel kalkylator. Det bör acceptera två nummer från användaren tillsammans med den nödvändiga operationen som ska utföras. Addition, Subtraction, Division och Multiplication är de grundläggande operationer som ska genomföras. Använd gärna andra transaktioner (Nybörjare) 18. Bestäm hur mycket pengar som finns i en spargris som innehåller flera 50 paise mynt, 25 paise mynt, 20 paise mynt, 10 paise mynt och 5 paise mynt. Använd följande värden för att testa ditt program. Fem 50 paise mynt, tre 25 paise mynt, två 20 paise mynt, en 10 paise mynt och femton 5 paise mynt. (Nybörjare) 19. Skapa ett enkelt Palindrom checkerprogram. Programmet bör tillåta användaren att ange en sträng och kontrollera om den givna strängen är en palindrom eller ej. Endast siffror och alfabet bör övervägas när du letar efter palindrom - alla andra tecken ska ignoreras. (nybörjare) 20. Skriv ett program som låter dig ange elevernas poäng och vikt. Programmet ska sedan beräkna ett vägt genomsnitt och poäng baserat på de data som användaren inmatat. (Nybörjare) Mellan 21. Skriv ett program som kommer att skriva ut alla par av primtal, vars summa är lika med det antal som användaren har angett. (föreslagna av Aniseed) (Intermediate) 22. Utveckla en djurklassificeringsprogram bas på djurriket. (för övning användningen av invånarklasser). 23. Skriv ett quizprogram, som hämtar frågan och svarar från en fil. Låt sedan användaren ta quizcount-poäng och returnera poäng. (Intermediate) 24. Skriv ett program som accepterar XHTML, analyserar och tar bort taggarna. Sedan skriver den ut den återstående texten. (Intermediate) 25. Skriv ett program som utför addition, subtraktion, multiplicering av matriser. Dimensionerna för båda matriserna skulle anges av användaren (dynamisk minnesallokering krävs). Användning av struktur eller en klass för att definiera matrisen skulle vara en bra idé. (Intermediate) 26. Skriv ett program som utför jobbet för att flytta filen från en plats till en annan. Källan och destinationsvägen kommer att anges av användaren. Utför nödvändig felkontroll och hantera undantagen i enlighet med detta. (Intermediate) 27. Skapa en sofistikerad länklista klass. Du borde kunna infoga och ta bort noder var som helst i listan, och noderna ska ha pekar till noder både framför och bakom dem. (Intermediate) 28. Skapa ett program som implementerar en databas i C. Fälten är hårdkodade och data sparas i en binär fil. Även om detta inte är riktigt flexibilitet, är du inte beroende av externa bibliotek eller funktioner. (Intermediate) Expert 1. Implementera din egen strstr. 2. Skriv ett program som fungerade som en personlig planerare. I vilken en användare kan skriva in händelse, notera saker att göra på visst datum. 3. Tic Tac Toe-programmet. 4. Enkelt filkryptering (med något enkelt som ROT13.) 5. Skriv ett telefonadressbokprogram med data-sparning i binära filer. Användarna bör kunna lägga till data. 6. Skriv ett enkelt löneprogram, som skulle inkludera lönesatser , och timmar arbeta för anställda 7. Skapa några klasser som modellen spelar kort. Använd sedan denna ram för att skapa ditt favoritkortspel. Blackjack..etc (expert) 8. Skapa några klasser som modell schackbitar. (Expert) 9. Skapa ett binärt träd som har söknings - och sorteringsfunktioner. (Expert) 10. Skapa en Quine, det vill säga ett program som skriver ut sin egen källkod. (Expert) 11. Implementera din egen version av standardmallabiblioteket. (Expert) - grafik 1. Skriv ett program för att rita en rektangel, ellips, kvadrat, cirkel, punkt och linje baserat på användarinmatning. (Nybörjare) 2. Skriv ett program för att emulera Microsoft Paint. Det går att byta mellan olika verktyg (cirkel, rektangel, suddgummi.) med pre-de bönade nyckelstänger. Mellanliggande 3. Skriv ett program för att plotta ett enkelt x-y-diagram för en kodad funktion (t ex ycos (x)). Det ska vara möjligt att zooma in på någon del av grafen. - Mellanliggande. 4. Skriv ett program för att plotta ett diagram med given ekvation för form yf (x) och ett intervall för x som kommandoradsargument. (t ex mygrafplotter-eqyxx-xmin-10, - xmax10) - Expert. (PS: mer att göra med ekvationslösning än grafik) 5. Skriv det klassiska brick-break-out-spelet. T. ex. se DX Ball. Expert. Senast ändrad den 11 aug 2008 kl 03:04 UTCGeneralt kan C och Java vara lika snabbt eller snabbare eftersom JIT-kompilatorn - en kompilator som sammanställer din IL första gången den körs - kan göra optimeringar som ett C-kompilerat program kan inte för att det kan fråga maskinen. Det kan avgöra om maskinen är Intel eller AMD Pentium 4, Core Solo eller Core Duo eller om den stöder SSE4 etc. AC-programmet måste kompileras i förväg, vanligtvis med blandade optimeringar så att den går ordentligt bra på alla maskiner, men det är inte optimerad så mycket som det kan vara för en enda konfiguration (dvs processor, instruktionsuppsättning, annan hårdvara). Dessutom tillåter vissa språkfunktioner kompilatorn i C och Java att göra antaganden om din kod som gör det möjligt att optimera vissa delar bort som bara inte är säkra för CC-kompilatorn att göra. När du har tillgång till pekare finns det många optimeringar som bara inte är säkra. Också Java och C kan göra höjningsallokering effektivare än C eftersom abstraktionsskiktet mellan sopkollektor och din kod gör det möjligt att göra alla dess höftkomprimering på en gång (en ganska dyr operation). Nu kan jag inte tala om Java på nästa punkt, men jag vet att C till exempel faktiskt tar bort metoder och metodsamtal när det vet att metoden är tom. Och det kommer att använda denna typ av logik i hela din kod. Såsom du kan se finns det många anledningar till varför vissa C - eller Java-implementeringar kommer att bli snabbare. Nu säger allt detta, specifika optimeringar kan göras i C som kommer att blåsa bort allt som du kan göra med C, särskilt i grafikområdet och när som helst du är nära hårdvaran. Pekare undrar här. Så beroende på vad du skriver, skulle jag gå med den ena eller den andra. Men om du skriver något som inte är maskinvaruberoende (drivrutin, videospel etc), skulle jag inte oroa mig för resultatet av C (igen kan inte tala om Java). Det går bra. En Java-sida pekar Swati på en bra artikel: JIT vs Static Compiler Som redan sagt i tidigare inlägg kan JIT sammanställa ILbytecode i inbyggd kod vid körning. Kostnaden för det nämndes, men inte till dess slutsats: JIT har ett stort problem att det inte kan kompilera allt: JIT-kompilering tar tid, så JIT kommer bara att kompilera vissa delar av koden, medan en statisk kompilator kommer att producera en full Inbyggd binär: För någon form av program kommer den statiska kompilatorn helt enkelt enkelt att överträffa JIT. Naturligtvis är C (eller Java eller VB) vanligtvis snabbare för att producera en livskraftig och robust lösning än C (om bara C har komplexa semantik och C-standardbiblioteket, medan det är intressant och kraftfullt, är ganska dåligt jämfört med det fulla omfattning av standardbiblioteket från eller Java), vanligtvis är skillnaden mellan C och Java JIT inte synlig för de flesta användare, och för de binära filer som är kritiska, du kan fortfarande ringa C-bearbetning från C eller Java (jämn om denna typ av inbyggda samtal kan vara ganska dyrt i sig). C metaprogrammering Observera att du vanligtvis jämför C runtime-kod med motsvarande i C eller Java. Men C har en funktion som kan överträffa JavaC ut ur rutan, det är mallmetaprogrammering: Kodbearbetningen kommer att utföras på kompileringstid (vilket ökar mycket sammanställningstid), vilket resulterar i noll (eller nästan noll) körtid. Jag har ändå sett en verklig effekt på detta (jag spelade bara med koncept, men då var skillnaden sekunder för körning för JIT, och noll för C), men det här är värt att nämna, förutom att mall metaprogrammering inte är trivial. Redigera 2011-06-10: I C spelas med typer på kompileringstid, vilket betyder att man producerar generisk kod som kallar icke generisk kod (t. ex. en generell parser från sträng till typ T, kallar standardbibliotek API för typer T det känner igen, och gör parsaren lätt sträckbar av användaren) är väldigt lätt och mycket effektiv, medan ekvivalenten i Java eller C är smärtsamt bäst att skriva och kommer alltid att vara långsammare och löst vid körning även när typerna är kända vid sammanställningstid, vilket betyder att ditt enda hopp är att JIT ska inline hela grejen. Redigera 2011-09-20: Teamet bakom Blitz (Hemsida Wikipedia) gick så långt och uppenbarligen är målet att nå FORTRANs prestanda på vetenskapliga beräkningar genom att flytta så mycket som möjligt från körningstid till kompileringstid, via C-mall-metaprogrammering . Så jag har ändå såg en verklig verkan på den här delen som jag skrev ovan synes existerande i verkligheten. Native C Memory Usage C har en minnesanvändning som skiljer sig från JavaC, och har därmed olika fördelar. Oavsett JIT-optimering, kommer inget att gå fort som direkt pekare åtkomst till minne (kan ignorera en minuts processorkuffar, etc.). Så, om du har angränsande data i minnet, kommer åtkomst till det via C-pekare (det vill säga C-pekare. Låt Caesar ge upphov till) kommer att gå gånger snabbare än i JavaC. Och C har RAII, vilket gör mycket bearbetning mycket enklare än i C eller ens i Java. C behöver inte använda att omfatta förekomsten av dess föremål. Och C har ingen slutklausul. Detta är inte ett fel. Och trots C-primitiva-liknande strukturer kostar C på stapelobjekten ingenting vid allokering och förstöring, och behöver ingen GC att arbeta i en oberoende tråd för att göra städningen. När det gäller minnesfragmentering är minnesallokatorer 2008 inte de gamla minnetilldelarna från 1980 som vanligtvis jämförs med en GC: C-fördelning kan inte flyttas i minnet, sant men då, som på ett Linux-filsystem: Vem behöver defragmentering av hårddisken när fragmentering händer inte Att använda rätt tilldelare för rätt uppgift bör ingå i verktyget C-utvecklare. Nu är det inte lätt att skriva tilldelare, och då har de flesta av oss bättre saker att göra, och för det mesta är RAII eller GC mer än tillräckligt bra. Redigera 2011-10-04: För exempel om effektiva tilldelare: På Windows-plattformar, sedan Vista, är Low Fragmentation Heap aktiverat som standard. För tidigare versioner kan LFH aktiveras genom att kalla WinAPI-funktionen HeapSetInformation). På andra operativsystem tillhandahålls alternativa tilldelare (se secure. wikimedia. orgwikipediaenwikiMalloc för en lista) Nu blir minnesmodellen något mer komplicerad med ökningen av multicore och multithreading-teknik. I det här fältet antar jag att den har fördelen, och jag fick höra Java, höll den övre marken. Det är lätt för vissa på den nakna metallhackern att prisa hans nära maskinkoden. Men nu är det ganska svårare att producera bättre sammansättning för hand än att låta kompilatorn till sitt jobb. För C blev kompilatorn vanligtvis bättre än hackaren sedan ett decennium. För C och Java är det ännu enklare. Ändå kommer den nya standarden C0x att införa en enkel minnemodell till C-kompilatorer, som kommer att standardisera (och därmed förenkla) effektiv multiprocessingparallelthreadcode i C, och göra optimeringar enklare och säkrare för kompilatorer. Men då ser du om några år om dess löften hålls sanna. CCLI vs CVB Obs! I det här avsnittet talar jag om CCLI, det vill säga C som värd, inte den infödda C. I förra veckan hade jag en utbildning om optimering och upptäckte att den statiska kompilatorn i alla fall är väldigt viktig. Så viktigt än JIT. Samma kod som sammanställts i CCLI (eller dess förfader, Managed C) kan vara gånger snabbare än samma kod som produceras i C (eller VB, vars kompilator producerar samma IL än C). Eftersom C-statisk kompilator var mycket bättre att producera redan optimerad kod än Cs. Funktionen inlining in är till exempel begränsad till funktioner vars bytekod är mindre eller lika med 32 bitars längd. Så, en del kod i C kommer att producera en 40 bytes accessor, som vanligtvis inte kommer att inriktas av JIT. Samma kod i CCLI kommer att producera en 20 byte accessor, som kommer att inriktas av JIT. Ett annat exempel är temporära variabler, som enkelt kompileras av C-kompilatorn medan de fortfarande nämns i IL som produceras av C-kompilatorn. C-statisk kompileringsoptimering kommer att leda till mindre kod, vilket ger en mer aggressiv JIT-optimering igen. Anledningen till detta var spekulerad att vara det faktum att CCLI-kompilatorn gynnades av de stora optimeringsteknikerna från C-native compiler. Slutsats Men så långt jag ser det, är C eller Java alldeles en bättre satsning. Inte för att de är snabbare än C, men för att när de lägger till sina egenskaper blir de mer produktiva, behöver mindre träning och har mer kompletta standardbibliotek än C. Och för de flesta av programmen är deras hastighetsskillnader (i en sätt eller annat) kommer att vara försumbar. Redigera (2011-06-06) Min erfarenhet på C Jag har nu 5 månader med nästan exklusiv professionell C-kodning (vilket lägger till mitt CV redan fyllt med C och Java och en touch av CCLI). Jag spelade med WinForms (Ahem.) Och WCF (cool) och WPF (Cool. Både genom XAML och raw C. WPF är så lätt jag tror att Swing bara inte kan jämföra med det) och C 4.0. Slutsatsen är att medan det är lättare att producera en kod som arbetar i CJava än i C, är det mycket svårare att producera en stark, säker och robust kod i C (och ännu svårare i Java) än i C. Skäl är överflödiga, men det kan sammanfattas av: Generics är inte lika kraftfulla som mallar (försök att skriva en effektiv generisk Parse-metod (från sträng till T) eller en effektiv ekvivalent av boost :: lexicalcast i C för att förstå problemet) RAII förblir oöverträffad (GC fortfarande kan läcka (ja, jag var tvungen att hantera det här problemet) och kommer bara att hantera minnet. Även Cs använder är inte lika lätt och kraftfullt för att skriva en korrekt. Avlägsna implementeringar är svåra. C readonly och Java final är ingenstans lika användbar som Cs const (Theres inget sätt att du kan avslöja läsligt komplicerade data (t. ex. ett träd av nodar) i C utan enormt arbete, medan det är en inbyggd egenskap hos C. Immutable data är en intressant lösning, men inte allt kan göras oföränderligt, så dess inte ens nog, överlägset). Så, C är ett trevligt språk så länge du vill ha något som fungerar, men ett frustrerande språk det ögonblick du vill ha något som alltid och säkert fungerar. Java är ännu mer frustrerande, eftersom det har samma problem än C och mer: Att missa motsvarande Cs med hjälp av sökord spenderade en mycket skicklig kollega av mig för mycket tid för att säkerställa att dess resurser var korrekt frigjorda, medan ekvivalenten i C skulle har varit lätt (med hjälp av förstörare och smarta pekare). Så jag antar att CJavas produktivitetsvinst är synlig för de flesta kod. tills den dag du behöver koden ska vara så perfekt som möjligt. Den dagen kommer du att veta smärta. (du tror inte vad som hänt från vår server och GUI-appar.). Om server-sidan Java och C Jag höll kontakt med servern lag (jag jobbade 2 år bland dem innan jag kom tillbaka till GUI-teamet), på andra sidan byggnaden, och jag lärde mig något intressant. Under de senaste åren var trenden att Java-servrarna skulle vara avsedda att ersätta de gamla C-serverns program, eftersom Java har många ramverk och är lätt att underhålla, distribuera etc. osv. Till problemet med låg latens uppfödde sitt fula huvud de senaste månaderna. Sedan misslyckades Java-serverns program, oavsett optimering som gjordes av vårt skickliga Java-team, helt enkelt och renat tävlingen mot den gamla, inte riktigt optimerade C-servern. För närvarande är beslutet att behålla Java-servrarna för allmänt bruk, där prestanda medan det fortfarande är viktigt, inte är oroad över målet lågt latens och aggressivt optimerar de redan snabbare C-serverns applikationerna för låga latens - och ultralågsbehov. Slutsats Ingenting är lika enkelt som förväntat. Java, och ännu mer C, är snygga språk, med omfattande standardbibliotek och ramverk, där du kan koda snabbt, och resultatet snart. Men när du behöver råkraft, kraftfulla och systematiska optimeringar, starkt kompilatorstöd, kraftfulla språkfunktioner och absolut säkerhet, gör Java och C det svårt att vinna de senaste saknade men kritiska kvalitetsprocenten du behöver för att vara över konkurrensen. Det är som om du behövde mindre tid och mindre erfarna utvecklare i CJava än i C för att producera genomsnittlig kvalitetskod, men å andra sidan, det ögonblick du behövde utmärkt för perfekt kvalitetskod var det plötsligt lättare och snabbare att få resultaten direkt i C. Det är naturligtvis min egen uppfattning, kanske begränsad till våra specifika behov. Men det är fortfarande vad som händer idag, både i GUI-lag och server-sidlag. Självklart uppdaterar jag detta inlägg om något nytt händer. Redigera (2011-06-22) Vi finner att med avseende på prestanda vinner C med stor marginal. Det krävde emellertid också den mest omfattande tuningansträngningen, varav många gjordes på en nivå av sofistikering som inte skulle vara tillgänglig för den genomsnittliga programmeraren. . Java-versionen var förmodligen det enklaste att implementera, men det svåraste att analysera för prestanda. Specifikt var effekterna kring sophämtning komplicerade och mycket svåra att ställa in. Redigera (2011-09-20) Gå på Facebook är den rimligt skrivna C-koden går bara fort, vilket understryker den enorma ansträngningen som används vid optimering av PHP och Java-kod. Paradoxalt nog är C-kod svårare att skriva än på andra språk, men effektiv kod är mycket lättare att skriva i C än på andra språk. quotKodbearbetningen kommer att göras vid sammanställningstidkvoten. Därför fungerar templatmetaprogrammering endast i programmet tillgängligt vid sammanställningstiden vilket ofta inte är fallet, t. ex. Det är omöjligt att skriva ett konkurrenskraftigt fungerande regelbundet uttrycksbibliotek i vanilj C, eftersom det inte kan generera run-time kodgenerering (en viktig aspekt av metaprogrammering). ndash Jon Harrop Jan 17 12 på 10:08 När jag pratar förvaltad mot okontrollerad prestanda, vill jag peka på serien Rico (och Raymond) jämförde C och C versioner av en kinesisk engelsk ordbok. Den här google-sökningen låter dig läsa själv, men jag gillar Ricos sammanfattning. Så skämmas jag nästan av mitt krossande nederlag. Den hanterade koden fick ett mycket bra resultat för knappast någon ansträngning. För att besegra den förvaltade Raymond var tvungen att: Skriv en egen fil IO saker Skriv en egen strängklass Skriv sin egen allokator Skriv en egen internationell kartläggning Självklart använde han tillgängliga lågnivåbibliotek för att göra det, men det är fortfarande mycket arbete. Kan du ringa vad som är kvar ett STL-program Jag tror inte det, jag tror att han behöll std :: vector-klassen som i slutändan aldrig var ett problem och han behöll funktionsfunktionen. Nästan allting är borta. Så, du kan definitivt slå CLR. Raymond kan få sitt program att gå ännu snabbare tror jag. Intressant är att tiden för att analysera filen som rapporterats av båda programmen internt timers är ungefär - 30ms för var och en. Skillnaden är i overhead. För mig är den övergripande att det tog 6 revisioner för den obestridda versionen att slå den hanterade versionen som var en enkel port i den ursprungliga omanagda koden. Om du behöver varje sista prestationsförmåga (och har tid och kompetens för att få det) måste du gå omhändertagna, men för mig, Ill tar jag storleksordningen fördel jag har på de första versionerna över de 33 jag får om jag prova 6 gånger. Först och främst, om vi tittar på Raymond Chen39s kod, förstår han inte klart C eller datastrukturer mycket bra. Hans kod når nästan helt till låg C-kod, även om C-koden inte har några fördelar (det verkar bara vara ett slags misstro och kanske brist på kunskap om hur man använder profiler). Han misslyckades också med att förstå den mest algoritmiskt sunda sättet att genomföra en ordlista (han använde std :: hitta för Kristi skull). Om det finns något bra om Java, Python, C, etc. - de ger alla mycket effektiva ordböcker. ndash stinky472 28 feb 12 kl 18:26 Tries eller ens std :: map skulle gå mycket mer positivt mot C eller till och med ett hashbord. Slutligen är en ordlista exakt den typ av program som gynnar mest från bibliotek på hög nivå och ramverk. Det visar inte skillnader på språket så mycket som de involverade biblioteken (av vilka skulle jag gärna säga att C är långt mer komplett och ger mycket mer verktyg som passar för uppgiften). Visa ett program som manipulerar stora block av minne i jämförelse, som en storskalig matrixvektorkod. Det kommer att lösa detta ganska snabbt även om, som i detta fall, kodarna inte vet vad. ndash stinky472 28 feb 12 kl 18:29 Det är inte så mycket att du sammanställer för CPU-optimering, men du sammanställer för runtime-sökvägsoptimering. Om du upptäcker att en metod ofta kallas med en viss parameter, kan du förkompilera den rutinen med den parametern som en konstant som kan (i fallet med en booleska som styr flödet) utmäta gigantiska arbetsstycken. C kan inte komma nära att göra den typen av optimering. ndash Bill K 9 okt 09 kl 17:42 Så hur gör JITs för att kompilera rutiner för att dra nytta av observerade körbanor, och hur stor skillnad gör det med David Thornley Dec 3 09 kl 21:50 Hardy ja, CPU kan göra filial förutsägelse oavsett språk, men det kan inte avgöra en hel slinga genom att observera att slingan inte har någon effekt på någonting. Det kommer inte heller att observera att mult (0) är hårdkopplad för att returnera 0 och bara ersätta hela metallsamtalet med om (param 0) result0 och undvika hela funktionmetodsamtalet. C skulle kunna göra det här om kompilatören hade en övergripande översikt över vad som hände, men generellt har det inte tillräckligt med information vid kompileringstid. ndash Bill K 8 sep 10 kl 17:26 JIT (Just In Time Compiling) kan vara oerhört snabbt eftersom det optimerar för målplattformen. Det innebär att det kan dra nytta av vilken kompilator som helst som din CPU kan stödja, oavsett vilken CPU utvecklaren skrev koden på. Grundläggande koncept för JIT fungerar så här (starkt förenklat): Ringa en metod för första gången: Din programkod kallar en metod Foo () CLR ser på typen som implementerar Foo () och får metadata som är associerade med det Från metadata, CLR vet vilken minnesadress IL (intermediate byte code) är lagrad i. CLR allokerar ett block av minne och kallar JIT. JIT sammanställer IL i inbyggd kod, placerar den i det tilldelade minnet och ändrar sedan funktionspekaren i Foo () s typmetadata för att peka på denna inbyggda kod. Koden är körd. Ringa en metod för andra gången: Din programkod kallar en metod Foo () CLR ser på typen som implementerar Foo () och finner funktionspekaren i metadata. Den inbyggda koden på det här minnesplatsen körs. Som du kan se, andra gången, är det nästan samma process som C, förutom med fördelen av realtidsoptimeringar. Det sägs att det fortfarande finns andra överliggande problem som bromsar ett hanterat språk, men JIT hjälper till mycket. Tja, det bygger på idén att en kompilators39 optimizer följer regler och kodar inte. Så det kommer alltid att vara kod som optimisten finner att den inte kan optimera perfekt, medan en människa kunde antingen genom att titta på en större bild eller veta mer om vad koden verkligen gör. I39ll tillägger att det här är en 3-årig kommentar, och jag vet mer om HotSpot än jag brukade, och jag kan enkelt se att dynamisk optimering är ett MYCKET trevligt sätt att få koden att springa snabbare. ndash billjamesdev Jul 14 11 på 6:03 1. Optimeringar från Hotspot eller någon annan JIT är fortfarande kompilatoroptimeringar. JIT har fördelen över en statisk kompilator för att kunna inline några resultat (kod ofta kallad), eller till och med för att göra optimeringar baserade på den exekverande processorn, men det är fortfarande en kompilatoroptimering. 2. Jag antar att du pratar om optimering av algoritmen, inte att finjustera finjustering. kvadratisk sammansättning finjustering av en human coderquot lyckades inte ge bättre resultat än kompilatoroptimeringar sedan mer än ett decennium. Faktum är att en mänsklig lek med montering vanligtvis skruvas bort eventuell optimering. ndash paercebal 14 Jul 11 ​​kl 16:46 Ok, jag förstår att I39m använder fel terminologi, quotcompiler optimiziationquot snarare än quotastatic optimizationquot. Jag vill påpeka att, åtminstone i spelbranschen, så nyligen som för PS2 använde vi fortfarande handkodad montering på plats för att quotoptimizequot för de specifika marker som vi visste var på konsolkorssamlare för att dessa nya marker inte var men ändå så sofistikerade som för x86-arkitekturer. Tillbaka till den ursprungliga frågan ovan: JIT har fördelen av att kunna mäta före optimering, vilket är en bra sak (ndash billjamesdev) 14 jul 11 ​​kl 17:53 Du borde definiera fungera bättre än ... Jo, jag vet du frågade om hastighet, men det är inte allt som räknas. Utför virtuella maskiner mer runtime-kostnader Ja, de äter mer arbetsminne Ja Har de högre startkostnader (runtime-initialisering och JIT-kompilator). Ja Behöver de ett stort bibliotek installerat Ja Och så vidare är det partisk, ja) Med C och Java betalar du ett pris för vad du får (snabbare kodning, automatisk minneshantering, stort bibliotek och så vidare). Men du har inte mycket utrymme att pruta om detaljerna: ta det kompletta paketet eller ingenting. Även om dessa språk kan optimera någon kod för att exekvera snabbare än sammanställd kod är hela tillvägagångssättet (IMHO) ineffektivt. Tänk dig att köra varje dag 5 miles till din arbetsplats, med en lastbil. Det är bekvämt, det känns bra, du är säker (extrem krumplingszon) och efter att du har gått på gasen för en tid kommer det även att vara lika snabb som en vanlig bil Varför inte vi alla har en lastbil att köra till jobbet) I C får du vad du betalar för, inte mer, inte mindre. Citera Bjarne Stroustrup: C är mitt favoritskräp samlat språk eftersom det genererar så lite skräp länk text Stroustrup har inte sett några av koden jag har. ndash kyoryu dec 4 09 at 3:29 jag tror att han har en bra uppfattning om dess nackdelar, han sa också: kvot gör det enkelt att skjuta dig i foten C gör det svårare, men när du gör det blåser hela ditt ben offquot) ndash Frunsi dec 4 09 vid 11:24 quotIn C du får vad du betalar för, inte mer, inte mindre. Tounterexempel: Jag benchmarkade en RB-trädimplementering i OCaml och C (GNU GCC) som använde ett undantag för långhopp ut från rekursionen om ett element som adderades redan var närvarande för att återanvända den befintliga uppsättningen. OCaml var upp till 6x snabbare än C eftersom det inte betalar för att kontrollera destructors eftersom stacken är avlindad. ndash Jon Harrop 5 september 11 kl 23:10 Jon: men vid vissa (senare) tidpunkt måste den förstöra föremålen i alla fall (åtminstone måste det släppa sitt minne). Och notera också att undantag är för exceptionella fall, åtminstone i C, att regeln bör respekteras. C-undantag kan vara tunga när undantag uppstår, det är en avvägning. ndash Frunsi 6 sep 11 kl 19:19 Några bra svar här om den specifika frågan du frågade. Jag gillar att gå tillbaka och titta på den större bilden. Tänk på att användarnas uppfattning om hastigheten på den programvara du skriver påverkas av många andra faktorer än hur bra kodgen optimeras. Här är några exempel: Manuell minneshantering är svår att göra korrekt (ingen läckage), och ännu svårare att göra effektivt (ledigt minne strax efter att du har gjort det). Att använda en GC är generellt mer sannolikt att producera ett program som hanterar minnet väl. Are you willing to work very hard, and delay delivering your software, in an attempt to out-do the GC My C is easier to read amp understand than my C. I also have more ways to convince myself that my C code is working correctly. That means I can optimize my algorithms with less risk of introducing bugs (and users dont like software that crashes, even if it does it quickly) I can create my software faster in C than in C. That frees up time to work on performance, and still deliver my software on time. Its easier to write good UI in C than C, so Im more likely to be able to push work to the background while UI stays responsive, or to provide progress or hearbeat UI when the program has to block for a while. This doesnt make anything faster, but it makes users happier about waiting. Everything I said about C is probably true for Java, I just dont have the experience to say for sure. The virtual machine languages are unlikely to outperform compiled languages but they can get close enough that it doesnt matter, for (at least) the following reasons (Im speaking for Java here since Ive never done C). 1 The Java Runtime Environment is usually able to detect pieces of code that are run frequently and perform just-in-time (JIT) compilation of those sections so that, in future, they run at the full compiled speed. 2 Vast portions of the Java libraries are compiled so that, when you call a library function, youre executing compiled code, not interpreted. You can see the code (in C) by downloading the OpenJDK. 3 Unless youre doing massive calculations, much of the time your program is running, its waiting for input from a very slow (relatively speaking) human. 4 Since a lot of the validation of Java bytecode is done at the time of loading the class, the normal overhead of runtime checks is greatly reduced. 5 At the worst case, performance-intensive code can be extracted to a compiled module and called from Java (see JNI) so that it runs at full speed. In summary, the Java bytecode will never outperform native machine language, but there are ways to mitigate this. The big advantage of Java (as I see it) is the HUGE standard library and the cross-platform nature. Re item 2, quot2 Vast portions of the Java libraries are compiled so that, when you call a library function, you39re executing compiled code, not interpretedquot: Do you have a citation for that If it were really as you describe, I39d expect to run into native code from my debugger a lot, but I don39t. ndash cero Sep 28 08 at 22:46 Re: cero Debuggers often utilize less efficient but more expressive paths, and are therefore not a good marker for anything performance related. ndash Guvante Oct 7 08 at 18:35 Orion Adrian. let me invert your post to see how unfounded your remarks are, because a lot can be said about C as well. And telling that JavaC compiler optimize away empty functions does really make you sound like you are not my expert in optimization, because a) why should a real program contain empty functions, except for really bad legacy code, b) that is really not black and bleeding edge optimization. Apart from that phrase, you ranted blatantly about pointers, but dont objects in Java and C basically work like C pointers May they not overlap May they not be null C (and most C implementations) has the restrict keyword, both have value types, C has reference-to-value with non-null guarantee. What do Java and C offer Generally, C and C can be just as fast or faster because the AOT compiler -- a compiler that compiles your code before deployment, once and for all, on your high memory many core build server -- can make optimizations that a C compiled program cannot because it has a ton of time to do so. The compiler can determine if the machine is Intel or AMD Pentium 4, Core Solo, or Core Duo or if supports SSE4, etc, and if your compiler does not support runtime dispatch, you can solve for that yourself by deploying a handful of specialized binaries. A C program is commonly compiled upon running it so that it runs decently well on all machines, but is not optimized as much as it could be for a single configuration (i. e. processor, instruction set, other hardware), and it must spend some time first. Features like loop fission, loop inversion, automatic vectorization, whole program optimization, template expansion, IPO, and many more, are very hard to be solved all and completely in a way that does not annoy the end user. Additionally certain language features allow the compiler in C or C to make assumptions about your code that allows it to optimize certain parts away that just arent safe for the JavaC compiler to do. When you dont have access to the full type id of generics or a guaranteed program flow theres a lot of optimizations that just arent safe. Also C and C do many stack allocations at once with just one register incrementation, which surely is more efficient than Javas and C allocations as for the layer of abstraction between the garbage collector and your code. Now I cant speak for Java on this next point, but I know that C compilers for example will actually remove methods and method calls when it knows the body of the method is empty, it will eliminate common subexpressions, it may try and retry to find optimal register usage, it does not enforce bounds checking, it will autovectorize loops and inner loops and will invert inner to outer, it moves conditionals out of loops, it splits and unsplits loops. It will expand std::vector into native zero overhead arrays as youd do the C way. It will do inter procedural optimmizations. It will construct return values directly at the caller site. It will fold and propagate expressions. It will reorder data into a cache friendly manner. It will do jump threading. It lets you write compile time ray tracers with zero runtime overhead. It will make very expensive graph based optimizations. It will do strength reduction, were it replaces certain codes with syntactically totally unequal but semantically equivalent code (the old xor foo, foo is just the simplest, though outdated optimization of such kind). If you kindly ask it, you may omit IEEE floating point standards and enable even more optimizations like floating point operand re-ordering. After it has massaged and massacred your code, it might repeat the whole process, because often, certain optimizations lay the foundation for even certainer optimizations. It might also just retry with shuffled parameters and see how the other variant scores in its internal ranking. And it will use this kind of logic throughout your code. So as you can see, there are lots of reasons why certain C or C implementations will be faster. Now this all said, many optimizations can be made in C that will blow away anything that you could do with C, especially in the number crunching, realtime and close-to-metal realm, but not exclusively there. You dont even have to touch a single pointer to come a long way. So depending on what youre writing I would go with one or the other. But if youre writing something that isnt hardware dependent (driver, video game, etc), I wouldnt worry about the performance of C (again cant speak about Java). Itll do just fine. ltltltltltltltltltlt Generally, certain generalized arguments might sound cool in specific posts, but dont generally sound certainly credible. Anyways, to make peace: AOT is great, as is JIT . The only correct answer can be: It depends. And the real smart people know that you can use the best of both worlds anyways. In some cases, managed code can actually be faster than native code. For instance, mark-and-sweep garbage collection algorithms allow environments like the JRE or CLR to free large numbers of short-lived (usually) objects in a single pass, where most CC heap objects are freed one-at-a-time. For many practical purposes, allocationdeallocation-intensive algorithms implemented in garbage collected languages can actually be faster than their equivalents using manual heap allocation. A major reason for this is that the garbage collector allows the runtime system to amortize allocation and deallocation operations in a potentially advantageous fashion. That said, Ive written a lot of C and a lot of C, and Ive run a lot of benchmarks. In my experience, C is a lot faster than C, in two ways: (1) if you take some code that youve written in C, port it to C the native code tends to be faster. How much faster Well, it varies a whole lot, but its not uncommon to see a 100 speed improvement. (2) In some cases, garbage collection can massively slow down a managed application. The CLR does a terrible job with large heaps (say, 2GB), and can end up spending a lot of time in GC--even in applications that have few--or even no--objects of intermediate life spans. Of course, in most cases that Ive encounted, managed languages are fast enough, by a long shot, and the maintenance and coding tradeoff for the extra performance of C is simply not a good one. Of course, the question is whether we39re comparing an implementation of a program in managed vs. unmanaged code, or the theoretical top performance of the language. Clearly, unmanaged code can always be at least as fast as managed, as in the worst case you could just write an unmanaged program that did exactly the same thing as the managed code But most performance issues are algorithmic, not micro. Also, you don39t optimize managed and unmanaged code the same way, so quotC in Cquot is usually going to not work well. ndash kyoryu Dec 4 09 at 3:27 In CC you can allocate short lived objects on the stack, and you do when its appropriate. In managed code you cannot . you have no choice. Also, in CC you can allocate lists of objects in contigous areas (new Foo100), in managed code you cannot. So, your comparison is not valid. Well, this power of choices places a burden on the developers, but this way they learn to know the world they live in (memory. ). ndash Frunsi Dec 6 09 at 3:39 Go read about HP Labs Dynamo. an interpreter for PA-8000 that runs on PA-8000, and often runs programs faster than they do natively. Then it wont seem at all surprising Dont think of it as an intermediate step -- running a program involves lots of other steps already, in any language. It often comes down to: programs have hot-spots, so even if youre slower running 95 of the body of code you have to run, you can still be performance-competitive if youre faster at the hot 5 a HLL knows more about your intent than a LLL like CC, and so can generate more optimized code (OCaml has even more, and in practice is often even faster) a JIT compiler has a lot of information that a static compiler doesnt (like, the actual data you happen to have this time) a JIT compiler can do optimizations at run-time that traditional linkers arent really allowed to do (like reordering branches so the common case is flat, or inlining library calls) All in all, CC are pretty lousy languages for performance: theres relatively little information about your data types, no information about your data, and no dynamic runtime to allow much in the way of run-time optimization. My understanding is that CC produces native code to run on a particular machine architecture. Conversely, languages like Java and C run on top of a virtual machine which abstracts away the native architecture. Logically it would seem impossible for Java or C to match the speed of C because of this intermediate step, however Ive been told that the latest compilers (hot spot) can attain this speed or even exceed it. That is illogical. The use of an intermediate representation does not inherently degrade performance. For example, llvm-gcc compiles C and C via LLVM IR (which is a virtual infinite-register machine) to native code and it achieves excellent performance (often beating GCC). Perhaps this is more of a compiler question than a language question, but can anyone explain in plain English how it is possible for one of these virtual machine languages to perform better than a native language Here are some examples: Virtual machines with JIT compilation facilitate run-time code generation (e. g. System. Reflection. Emit on ) so you can compile generated code on-the-fly in languages like C and F but must resort to writing a comparatively-slow interpreter in C or C. For example, to implement regular expressions. Parts of the virtual machine (e. g. the write barrier and allocator) are often written in hand-coded assembler because C and C do not generate fast enough code. If a program stresses these parts of a system then it could conceivably outperform anything that can be written in C or C. Dynamic linking of native code requires conformance to an ABI that can impede performance and obviates whole-program optimization whereas linking is typically deferred on VMs and can benefit from whole-program optimizations (like s reified generics). Id also like to address some issues with paercebals highly-upvoted answer above (because someone keeps deleting my comments on his answer) that presents a counter-productively polarized view: The code processing will be done at compilation time. Hence template metaprogramming only works if the program is available at compile time which is often not the case, e. g. it is impossible to write a competitively performant regular expression library in vanilla C because it is incapable of run-time code generation (an important aspect of metaprogramming). playing with types is done at compile time. the equivalent in Java or C is painful at best to write, and will always be slower and resolved at runtime even when the types are known at compile time. In C, that is only true of reference types and is not true for value types. No matter the JIT optimization, nothing will go has fast as direct pointer access to memory. if you have contiguous data in memory, accessing it through C pointers (i. e. C pointers. Lets give Caesar its due) will goes times faster than in JavaC. People have observed Java beating C on the SOR test from the SciMark2 benchmark precisely because pointers impede aliasing-related optimizations. Also worth noting that does type specialization of generics across dynamically-linked libraries after linking whereas C cannot because templates must be resolved before linking. And obviously the big advantage generics have over templates is comprehensible error messages. C Fundamentals for Borland C Builder 2012-05-14 04:31:36 By Console77 Version: C Fundamentals for Borland C Builder 6.0 Easy for beginners, else none - No reliable internet components - Simple graphics, unless you dare rely on thirds party VCLs - No 64bit support - Buggy - Thirdparty VCLs are also buggy - Not a standard product - Less and less vendors supports DelphiC Builder - Insecure future, a sinking ship Embarcadero and their products are a sinking ship, together with the third party tools. There are always problems, bugs, or simply a connectivity is not supported. You never know if it is You, the third part VCL vendor or Emarcadero creating the problems. We have used an obsene amount of time in error finding, debugging. There is still no support for 64bit in C Builder, and the datasnap is unreliable, new releases are always buggy. Emrabadero has no reliable internet connectivity, but rely on Indy, which is unreliable and very difficult to manage. We now face more and more that we need to add plug-ins to our application, but they are not supporting Delphi C Builder. So, we now have to migrate to the standard, which is Visual Studio 2010. Perhaps for hobby projects DelphiC Builder is ok - but not for commercial applications. 34I use before old version34