C# Överlagrade Metoder

Hej, @Zero_Digits, och välkommen till Sweclockers!

När du lägger upp programkod på forumet är det bra om du lägger in texten [code] före och [/code] efter din kodsnutt. På det sättet så syns även indrag i koden på korrekt sätt. Det är svårt att läsa kod som saknar indrag, man tappar all struktur.

Jag har gjort detta åt dig den här gången, men nästa gång är det bra om du gör det själv.

Med vänlig hälsning,
pv2b (Moderator)

Hej!

Du har nog inte riktigt lyckats lösa uppgiften som den är skriven.

För det första fungerar inte din kod alls. Metoderna CelsiusToFahrenheit och CelsiusToFahrenheitF anropar metoden CTF() på celsius, kastar bort svaret, och returnerar sedan värdet i celsius som matades in från början. (Edit: Tja, den "verkar" ju ut att funka om du bara kör koden direkt, men det är för att du kör Console.Writeline() inuti CTF...)

För det andra har du inte använt överlagrade metoder. En överlagrad metod är när du har två eller fler metoder med samma namn som tar olika sorters argument. Här har du istället två metoder med två olika namn.

För det tredje så har du krånglat till CTF() något rejält. Det jag hade gjort hade varit att istället skapa en metod CTF som tar en "double" som indata, och sedan skickar tillbaka en "double" som returvärde.

I metoden CelsiusToFahrenheit(double) hade jag då anropat denna metod rakt av och returnerat svaret. I metoden CelsiusToFahrenheit(int) hade jag då konverterat antalet grader till en double, anropat CTF, och redan konverterat tillbaka resultatet till en int. Att kolla vilken typ objektet är av och castning är ju bra att ha lärt sig, men det är egentligen inte alls syftet med uppgiften.

Lycka till i Programmering 1!

Detta beror på att du skriver ut resultaten i slutet av metoden CTF(). Men det resultatet skrivs bara ut på skärmen. Uppgiften vill ju att värdet ska komma i retur när du anropar funktionen. Console.Writeline() ska alltså stå i din main-metod någonstans efter att du kört dina CelsiusToFahrenheit-metoder.

Typen "void" betyder att metoden inte skickar tillbaka något returvärde. Ett exempel:

static void SayHello(string name) {
    Console.WriteLine("Hello, " + name + "!");
}

I det fallet så får inte den metod som anropar metoden SayHello() något i retur, utan den skriver bara ut på skärmen. Jämför detta med:

static void SayHello(string name) {
    string greeting = "Hello, " + name + "!");
    return greeting;
}

Exemplet ovan skriver inte ut något på skärmen, utan genererar istället en sträng med texten "Hello, Niklas!" (om du anropar SayHello("Niklas") alltså.)

void betyder alltså inte "okänd typ", utan den betyder "ingenting".

Om du ska beteckna "okänd typ" så är det närmaste du kommer i C# "object".

Nej. Du ska inte ha en private metod som tar emot två olika datatyper. Du ska ha en privat metod CTF i "bakgrunden" som gör själva uträkningar, och dina publika metoder CelsiusToFahrenheit med olika typsignaturer (olika sorters värden den kan ta som argument) ska istället konvertera värdena så att de "passar in i" CTF.

Ett enkelt exempel på hur överlagring funkar:

using System;
					
public class Program
{
	public static void hej(double xxx) {
		Console.WriteLine("Det här är en double!");
	}
	
	public static void hej(int xxx) {
		Console.WriteLine("Det här är en int!");
	}
	
	public static void Main()
	{
		hej(1.0); // double
		hej(1);   // int
	}
}

https://dotnetfiddle.net/7XeCCp

Alltså, vilken metod som anropas beror på vilket slags värde du stoppar in!

        static int CelsiusToFahrenheit(int celsius)
        {
            CTF(celsius);
            return celsius;
        }

När du anropar CelsiusToFahrenheit(100) så händer följande:

1. Metoden CTF(celsius) anropas. Men du sparar aldrig returvärdet. (I och för sig såg jag ju sedan att metoden CTF returnerar "void", så här finns aldrig något returvärde att returnera.
2. Du returnerar sedan värdet i celsius, d.v.s. INTE konverterat!

Det är detta jag menade.

Ser mycket bättre ut! Finns några små stilgrejer men i allt väsentligt har du löst uppgiften som den är skriven!

Bra jobbat.

Skickades från m.sweclockers.com

Hittade en liten grej som är fel, men programmet funkar ändå.

Se nedan:

static int CelsiusToFahrenheit(int celsius)
        {
            // Gör om int celsius till double grader
            double grader = Convert.ToDouble(celsius);
            // Men sedan använder vi aldrig grader, utan skickar in int celsius istället. Vilket gör raden ovan helt meningslös. Anledningen till att detta fungerar ändå är att C# är smart nog att konvertera mellan datatyper automatiskt när det funkar
            grader = CTF(celsius);
            // På samma sätt skulle du kunna skippa den explicita konverteringen här och bara köra return grader
            int grader2 = Convert.ToInt32(grader);
            return grader2;
        }

Skickades från m.sweclockers.com

Vi tar det rad för rad:

public static int FahrenheitToCelsius(int celsius)  
{

Du definierar att metoden tar in en int, och returnerar en int.

    double fahrenheit = FTC(celsius); //Heltalet sätts in i metoden utan att man behöver konvertera data typ till double?

Exakt så! C# är smart nog att fatta att FTC vill ha en double, och konverterar automatiskt en int till en double utan att du behöver skriva detta explicit.

Detta kan förresten göras helt säkert utan dataförlust. En double kan representera alla möjliga tal som en int kan representera. (Men inte tvärtom! Se nedan.)

    int fahrenheit2 = Convert.ToInt32(fahrenheit); //Måste konvertera tillbaka till int även fast jag aldrig konverterade till double?
    return fahrenheit2; //fahrenheit2 returneras med det nya värdet
}

Du konverterade aldrig till double explicit, nej, men det som spelar roll är att FTC ger sitt resultat som en double. Därför "måste" det konverteras till int, även om det kan göras implicit.

Här kunde du bara ha skrivit "return fahrenheit" istället om du ville. På samma sätt kan C#-kompilatorn automatiskt konvertera en double till en int. Den vet ju att du vill ha en int tillbaka ur metoden (står längst upp i metodsignaturen).

Nu här nedan blir det överkurs.

Här finns faktiskt möjlighet att du förlorar lite data. Tänk på att en double kan representera många fler sorters värden än en int kan. Int kan bara representera heltal mellan -2³¹ och 2³¹ - 1. En double kan representera ett tal med decimaler, och även en mycket större räckvidd. Det är rent teoretiskt möjligt att du kanske skickar in 2³¹ - 1 som invärde i celsius, och ditt svar i fahrenheit blir för stort för att få plats i en int.

En annan grej är att när du bara "konverterar" ett flyttal till en int så blir det inte en avrundning till närmaste heltal, utan istället "hugger man bara av" decimalerna. T.ex:

double hej = 1.99;
int hopp = hej; // hej sätts till 1

Här kanske ett mer önskvärt resultat är att du avrundar till närmaste heltal. Detta kan du göra i C# med metoden Math.Round(Double). (Om du läser lite på den här dokumentationssidan så hittar du förresten lite mer exempel på överlagring, flera funktion med samma namn. Den du vill använda tar en Double som argument, och returnerar en Double.)

double hej = 1.99;
int hopp = Math.Round(hej); // hej sätts till 2

Sista raden i din FahrenheitToCelsius skulle alltså kunna vara:

return Math.Round(fahrenheit);

I det fallet så är fahrenheit en double, vilket är precis vad Math.Round vill ha. Math.Round returnerar det avrundade svaret till närmaste heltal, men representerar fortfarande svaret i en double. Men implicit konverteras detta igen till ett heltal, genom att trunkera det avrundade värdet (vilket ju blir precis vad du vill i det läget.)

Genom att avrunda så kommer dina värden bli närmare verkligheten för heltal, istället för att konsekvent visa lite för låga värden.

Du har helt rätt! I C funkar det som jag beskrev, men i C# behövs en explicit konvertering.

Förmodligen just för att du aldrig tappar någon information i konvertering från int till double, men du kan göra det åt andra hållet.

Däremot kan man ju göra så här:

using System;

public class Program
{
	public static void Main()
	{
		double a = 1.99;
		int b = (int)a;
		int c = (int)Math.Round(a);
		Console.WriteLine("b = " + b); // skriver ut b = 1
		Console.WriteLine("c = " + c); // skriver ut c = 2
	}
}

https://dotnetfiddle.net/GhiYw6

I det fallet så används en explicit "typecast" (där jag skriver (int)) för att konvertera värdet.

@Zero_Digits: int kan som sagt konverteras förlustfritt till double, men inte tvärtom. Det handlar alltså inte om att C# inte kan göra det, utan om att C# kräver att du explicit talar om att du faktiskt vill utföra konverteringen även fast det innebär en förlust av information.

Det är alltså på det sättet för att undvika att du av misstag råkar konvertera double till int (lätt hänt i lite mer komplicerad kod). I t.ex. C är det däremot som pv2b säger tillåtet, eftersom C inte bara låter dig skjuta dig själv i foten utan glatt räcker över geväret

Din CTF-metod involverar förresten decimaler eftersom du utför division, 21°C är t.ex. 69.8°F. Men även om metoden alltid skulle returnera värden som kan tolkas förlustfritt som heltal så är det på det stora hela enklare att ha en regel som alltid gäller än att ha specialfall.

Ska verkligen metoden som tar emot en int returnera en int? Då formeln multiplicerar med 1.8 (9 / 5) är det troligt att du får decimaler även vid konvertering av celsius i heltal. Att kasta bort dessa decimaler bara för att du anropat med ett heltal låter konstigt. (Uppgiften är iofs rätt konstig i helhet, då vi konstaterat att du inte ens behöver ha en metod som tar emot int iom implicit konvertering av int till double)