Transcript predavanje03

RP3/predavanje02
Programski jezik C#:
 Klase
09/04/2015
---------- Računarski praktikum 3 ---------Maja Starčević
1
Klase
Klasa je referentni tip.
Potpuna sintaksa je:
[ atributi ][ modifikatori ] class identifikator [:
bazna klasa [, sučelja] ]
{
tijelo klase
}
Nap: Uvijek se prvo navodi bazna klasa pa tek onda sučelje ili sučelja.
09/04/2015
-------Računarski praktikum 3-------
2
Klase
Napomena:
namespace Imenik
{
class C { … }
// standardan zapis definicije klase
class D { … } ; // može i ovako
class E { … } objekt; // pogrešno, nemoguće je definirati
varijablu direktno unutar prostora
imena niti unutar globalnog prostora
}
09/04/2015
-------Računarski praktikum 3-------
3
Klase
Bazna klasa, sučelje ili
sučelja koja klasa
implementira, ograničenja na
parametre kod generičkih
klasa.
class ImeKlase
{
}
Članovi klase: varijable članice (engl. field),
metode, svojstva, konstruktori, događaji,
indekseri, operatorske funkcije,
ugniježdeni tipovi, finalizatori.
Atributi ili klasni modifikatori:
- za neugniježdene klase: public, internal, abstract, sealed,
static, unsafe, partial
- za ugniježdene klase su dozvoljeni i svi preostali modifikatori
pristupa
09/04/2015
-------Računarski praktikum 3-------
4
Primjer klase
class Student
{
varijabla članica
metoda
string ime;
public void IspisiIme ( )
{
Console.WriteLine (ime);
}
public Student (string ime)
{
this.ime=ime;
}
}
09/04/2015
konstruktor
...u Main metodi ...
Student s = new Student(“Ema");
s.IspisiIme();
-------Računarski praktikum 3-------
5
Modifikatori pristupa
Klase i njihovi članovi mogu kontrolirati svoju pristupačnost
pomoću sljedećih modifikatora.
private
Član klase je vidljiv samo metodama koje su
članovi iste klase.
protected
Članovi su vidljivi metodama klase kojoj
pripadaju i metodama iz nje izvedenih klasa.
public
Članu klase mogu pristupati metode svih
klasa.
internal
Dostupnost svim metodama koje pripadaju
klasama iz istog asemblija.
protected internal Dostupnost klasama iz istog asemblija i
izvedenim klasama.
09/04/2015
-------Računarski praktikum 3-------
6
Modifikatori pristupa
Default modifikator pristupa za klasu je internal (klase se
često kreiraju kao podrška drugim klasama iz istog
asemblija).
Za varijable članice klase i njezine metode, default vidljivost
je private.
Preporučljivo je eksplicitno navoditi modifikator pristupa.
Ako klasa ima drugačiju pristupačnost od člana klase, na
član klase primjenjuje se ona koja je restriktivnija.
09/04/2015
-------Računarski praktikum 3-------
7
Modifikatori pristupa
Primjer:
class C
{
public void Metoda ( ) { }
}
Klasi C je implicitno dodijeljen modifikator internal, što znači da
i Metoda u biti ima modifikator internal (restriktivniji od public).
Ukoliko se klasi C promijeni modifikator u public, svi public
modifikatori članova klase postaju važeći, što može ubrzati
promjene u kodu
09/04/2015
-------Računarski praktikum 3-------
8
Instance i statički članovi
Član klase može biti instantni ili statički.
Instanciranje je stvaranje objekta klase. Druga instanca
(objekt) klase ima svoj zaseban skup podataka.
Ključna riječ static ispred člana klase označava da u
zadanom vremenu može postojati samo jedan primjerak tog
člana klase.
Statičke metode se pozivaju pomoću naziva klase (ne mogu
se pozivati na objektu te klase). Mogu raditi samo sa
statičkim članovima klase unutar koje su definirane ili s
njenim konstantama. Mogu se preopterećivati. Ne smiju
imati modifikatore abstract, virtual, override.
09/04/2015
-------Računarski praktikum 3-------
9
Statičke klase
Statička klasa sadrži samo statičke članove i konstante.
Zapečaćena je implicitno (greška je navesti eksplicitno
sealed), odnosno ne može se naslijediti. Također se ne
može izvesti ni iz jedne druge klase (statičke klase
nasljeđuju klasu object).
Označava se modifikatorom static:
static class C {
static public void f() { … }
}
Statičke klase ne mogu sadržavati konstruktore instance (ne
mogu se instancirati), već samo statičke konstruktore.
Primjeri statičkih klasa:
System.Console, System.Math
09/04/2015
-------Računarski praktikum 3-------
10
Statičke klase
class A
{
int a;
}
static class B : A
// greška, statička klasa ne može naslijeđivati
{
static int i;
static void Print(){ Console.Write(i); }
}
class C : A
// u redu
{
static int i;
static void Print() { Console.Write(i); }
}
09/04/2015
-------Računarski praktikum 3-------
11
Instance
using System;
class Tester
{
void Ispis()
{
Console.WriteLine(“Test”);
}
static void Main(string[] args)
{
Tester test=new Tester();
test.Ispis();
Stvaranje
instance klase
Tester
}
}
09/04/2015
-------Računarski praktikum 3-------
12
Konstruktori
Konstruktori instance izvršavaju kod inicijalizacije klase.
public class Student
{
string ime;
public Student (string n)
{
ime=n;
}
Definicija konstruktora
}
……
Student s=new Student(“Marko”);
09/04/2015
-------Računarski praktikum 3-------
13
Konstruktori
Klasa može preopteretiti svoj konstruktor pozivajući se na
neki drugi konstruktor za istu klasu. Pritom se koristi ključna
riječ this:
public class Student
{
public string Ime;
// imena javnih varijabli pišemo Pascal
public string Prezime; // notacijom
public Student (string ime) { Ime=ime; }
public Student (string ime, string prezime)
:this(ime) { Prezime=prezime; }
}
09/04/2015
-------Računarski praktikum 3-------
14
Konstruktori
U sljedećem primjeru koristimo this u dvije svrhe – za
razlikovanje parametra konstruktora od varijable klase, te za
pozivanje konstruktora s drugačijim potpisom.
public class Student
{
string ime;
string prezime;
public Student (string ime) { this.ime=ime; }
public Student (string ime, string prezime)
:this(ime) { this.prezime=prezime; }
}
09/04/2015
-------Računarski praktikum 3-------
15
Konstruktori
public class Student
{
private string ime;
class Program
{
static void Main(string[ ] args)
{
public Student (string ime )
{
this.ime = ime;
}
public string Ime
{
get { return ime; }
set { ime = value; }
}
}
09/04/2015
Student s = new Student("Maro");
Console.WriteLine(s.Ime);
}
}
Definicija svojstva Ime.
Svojstvo najčešće služi za čitanje i/ili
pisanje u neku privatnu varijablu. U
pravilu su svojstvo i pripadna varijabla
istog imena, a razlikuju se u notaciji koja
odgovara razini pristupa.
-------Računarski praktikum 3-------
16
Konstruktori
C# kompilator automatski generira konstruktor bez
parametara za klasu ako i samo ako nije definiran nijedan
drugi konstruktor.
Ukoliko je definiran neki od konstruktora koji prima barem
jedan parametar, konstruktor bez parametara nije
automatski generiran, ali se može eksplicitno definirati.
Postoje i statički konstruktori koji se izvršavaju prije nego je
kreirana ijedna instanca tipa.
09/04/2015
-------Računarski praktikum 3-------
17
Statički konstruktor
Statički konstruktor se za neki tip izvršava samo jednom,
prije nego što je stvoren ijedan objekt tog tipa i prije nego što
se pristupilo ijednom statičkom članu tog tipa. Ne može se
pozivati eksplicitno.
U definiciji tipa može se nalaziti samo jedan statički
konstruktor. Ima isto ime kao i tip, a lista parametara mu je
prazna.
Jedini dozvoljeni modifikatori za ovakav konstruktor su
unsafe i extern.
09/04/2015
-------Računarski praktikum 3-------
18
Statički konstruktor
public class Test
{
public static int i;
public int p;
static Test()
{
Console.WriteLine("Izvrsena je inicijalizacija tipa.");
Console.WriteLine("Vrijednost statičke varijable je {0}.", i);
}
}
09/04/2015
-------Računarski praktikum 3-------
19
Statički konstruktor
class Program
{
static void Main(string[] args)
{
Console.WriteLine(Test.i);
}
}
Output:
Izvrsena je inicijalizacija tipa.
Vrijednost staticke varijable je 0.
0
09/04/2015
-------Računarski praktikum 3-------
Zadatak: što
ispisuje
program ako
izbacimo
naredbu?
20
Copy konstruktor
C# ne pruža copy konstruktor. Za kopiranje vrijednosti iz
postojećeg objekta potrebno je napisati vlastitu metodu.
Primjer 1:
public class Osoba
{
private string ime;
private string prezime;
public Osoba(Osoba nekaOsoba)
{
ime = nekaOsoba.ime;
prezime = nekaOsoba.prezime;
}
09/04/2015
-------Računarski praktikum 3-------
Copy konstruktor
21
Copy konstruktor
public Osoba(string ime, string prezime)
{
this.ime = ime;
this.prezime = prezime;
}
public override string ToString()
{
return ime + " "+ prezime;
}
}
09/04/2015
-------Računarski praktikum 3-------
22
Copy konstruktor
class Program
{
static void Main(string[] args)
{
Osoba osoba1=new Osoba("Ana", "Anic");
Osoba osoba2=new Osoba(osoba1);
Console.WriteLine(osoba1.ToString());
Console.WriteLine(osoba2.ToString());
}
}
09/04/2015
-------Računarski praktikum 3-------
23
Copy konstruktor
Primjer 2:
public class RezultatiZadaca
{
public string ImeStudenta;
public int[ ] Ocjene= new int[5];
public RezultatiZadaca(string ime, params int[ ] o)
{
ImeStudenta=ime;
for (int i = 0; i < 5; ++i)
Ocjene[i] = o[i];
}
09/04/2015
-------Računarski praktikum 3-------
24
Copy konstruktor
public RezultatiZadaca(RezultatiZadaca rz)
{
this.ImeStudenta=rz.ImeStudenta;
this.Ocjene=rz.Ocjene;
}
public void IspisiRezultate()
{
Console.WriteLine(String.Format("\nStudent {0} je dobio
ocjene:", ImeStudenta));
for (int i=0; i<5; ++i)
Console.Write(String.Format("{0}", Ocjene[i]));
}
}
09/04/2015
-------Računarski praktikum 3-------
25
Copy konstruktor
1. pokušaj kopiranja objekta:
class Program
{
static void Main(string[] args)
{
RezultatiZadaca rz1 =
new RezultatiZadaca("Igor Igric", 2, 3, 4, 1, 5);
RezultatiZadaca rz2 = rz1;
rz2.ImeStudenta = "Matej Matic";
rz2.Ocjene[4] = 1;
rz1.IspisiRezultate();
rz2.IspisiRezultate();
}
}
09/04/2015
-------Računarski praktikum 3-------
26
Copy konstruktor
Output:
Student Matej Matic je dobio ocjene:
23411
Student Matej Matic je dobio ocjene:
23411
09/04/2015
-------Računarski praktikum 3-------
27
Copy konstruktor
2. pokušaj kopiranja objekta:
class Program
{
static void Main(string[] args)
{
RezultatiZadaca rz1 =
new RezultatiZadaca("Igor Igric", 2, 3, 4, 1, 5);
RezultatiZadaca rz2 =
new RezultatiZadaca(rz1);
rz2.ImeStudenta = "Matej Matic";
rz2.Ocjene[4] = 1;
rz1.IspisiRezultate();
rz2.IspisiRezultate();
}
}
09/04/2015
-------Računarski praktikum 3-------
28
Copy konstruktor
Output:
Student Igor Igric je dobio ocjene
23411
Student Matej Matic je dobio ocjene:
23411
problem
Zadatak: napravite duboku kopiju.
09/04/2015
-------Računarski praktikum 3-------
29
Copy konstruktor
struct S
{
public int a;
public S(S str) { a = str.a + 1; }
public void Ispisi(){ Console.Write(a); }
}
static void Main()
{
S s1;
s1.a = 1;
S s2 = s1;
S s3 =new S(s1);
s1.Ispisi();
s2.Ispisi();
s3.Ispisi();
}
09/04/2015
-------Računarski praktikum 3-------
30
Copy konstruktor
struct S
{
public int a;
public S(S str) { a = str.a + 1; }
public void Ispisi(){ Console.Write(a); }
}
static void Main()
{
S s1;
s1.a = 1;
S s2 = s1;
S s3 =new S(s1);
s1.Ispisi();
s2.Ispisi();
s3.Ispisi();
}
09/04/2015
// copy konstruktor se mora pozvati eksplicitno
// 1 1 2
-------Računarski praktikum 3-------
31
Clone
Metoda Clone ( public object Clone( ); ) u System.Array
stvara plitku kopiju instance.
int[ ] a = { 0, 1, 2 };
int[ ] b = ( int[ ] )a.Clone();
int[ ] c = a;
c[0] = 5;
Output:
5, 0, 5
Console.WriteLine("{0}, {1}, {2}", a[0], b[0], c[0]);
Napomena: Klasa Array pruža i CopyTo metodu.
09/04/2015
-------Računarski praktikum 3-------
32
Clone
Zadatak: što ispisuje sljedeći kod?
string s1 = "Test";
string s2 = s1;
string s3 = (string)s1.Clone();
Console.WriteLine("{0}, {1}", s1 == s2, s2 == s3 );
09/04/2015
-------Računarski praktikum 3-------
33
Clone
Zadatak: što ispisuje sljedeći kod?
string s1 = "Test";
string s2 = s1;
string s3 = (string)s1.Clone();
Console.WriteLine("{0}, {1}", s1 == s2, s2 == s3 ); //True, True
String objekt je nepromjenjiv za razliku od StringBuildera
objekta. Metoda Clone ne radi ništa, tj. vraća istu referencu.
Klasa StringBuilder ne definira metodu Clone.
Napomena: analogan primjer s int[] ispisuje True, False.
09/04/2015
-------Računarski praktikum 3-------
34
this
Ključna riječ this koristi se za referiranje na trenutnu
instancu objekta.
To je skrivena referenca koja se prosljeđuje svakoj
nestatičkoj metodi klase pomoću koje se ona može referirati
na druge metode i varijable pripadnog objekta.
U pravilu ju ne treba eksplicitno navoditi. Koristi se za
razlikovanje lokalne varijable ili argumenta od člana klase te
za referiranje na cijeli objekt.
Koristi se i kod preopterećivanja konstruktora, definicije
indeksera i metoda proširenja.
09/04/2015
-------Računarski praktikum 3-------
35
this
Referenca this se različito tretira u klasama i strukturama.
U klasama je ona vrijednost, odnosno ne može joj se
pridruživati.
U strukturama je out parametar u konstruktoru i ref
parametar u ostalim metodama, dakle može joj se mijenjati
vrijednost.
09/04/2015
-------Računarski praktikum 3-------
36
this
class CPoint
{
int x, y;
public void TestThis(CPoint cp)
{
this = cp; // greška
}
}
09/04/2015
-------Računarski praktikum 3-------
37
this
struct SPoint
{
int x, y;
class Program
{
static void Main(string[] args)
{
public SPoint(int x, int y)
{
this.x = x; this.y = y;
}
SPoint sp1=new SPoint(1,1);
SPoint sp2 = new SPoint(2,2);
public void TestThis(SPoint cp)
{
this = cp;
}
public override string ToString()
{
return String.Format("{0}, {1}", x, y);
}
}
09/04/2015
Console.WriteLine(sp1.ToString());
// 1 1
sp1.TestThis(sp2);
Console.WriteLine(sp1.ToString());
// 2 2
}
}
-------Računarski praktikum 3-------
38
Varijable članice klase
Varijable članice klase ne moraju se eksplicitno inicijalizirati.
U tom slučaju se implicitno inicijaliziraju na default vrijednost
(0, ‘\0’ ili false za vrijednosne tipove, te null za referentne
tipove).
Dozvoljena je deklaracija više varijabli istog tipa u istoj liniji.
Varijable članice mogu imati readonly modifikator koji
sprječava njihovu promjenu nakon inicijalizacije. Takvoj
varijabli se može dodijeliti vrijednost samo pri deklaraciji ili
unutar konstruktora za pripadni tip.
09/04/2015
-------Računarski praktikum 3-------
39
Konstante
Konstante su varijable klase kojima se vrijednost nikad ne
mijenja. Mogu biti bilo kojeg od ugrađenih numeričkih tipova,
zatim tipa bool, char, string ili enum. Konstanta može biti i
referenca s vrijednosti null.
Konstanta se može definirati unutar neke klase ili strukture.
Pritom može imati bilo koji od pet spomenutih modifikatora
pristupa. Ne može se označiti kao static. Mora se
inicijalizirati na mjestu deklaracije.
public class Krug
{
public const double dvaPi= 2*System.Math.PI;
}
09/04/2015
-------Računarski praktikum 3-------
40
Konstante
Vrijedi pravilo: konstanta koja je referentnog tipa može biti
inicijalizirana samo s null. Jedina iznimka je referenca tipa
string.
class B { public int i; }
class C
{
public const B c=new B(); // greška
public const B cc=null;
public const string ccc="Ovo je u redu";
}
09/04/2015
-------Računarski praktikum 3-------
41
Konstante
Konstantama u klasi ili strukturi se pristupa kao i statičkim
članovima. Dakle pritom se koristi ime tipa. Konstanti se ne
može pristupiti pomoću objekta te klase, odnosno strukture.
double d=Krug.dvaPI;
Krug k=new Krug();
double dd= k.dvaPi; //greška
09/04/2015
-------Računarski praktikum 3-------
42
Konstante
Konstanta se može deklarirati i lokalno, samo za metodu.
static void Main()
{
const string Poruka= “Hello World!”;
}
Podsjetnik: Imenički prostor ne može sadržavati članove
poput varijabli i funkcija (dakle ne postoje ni globalne
konstante).
09/04/2015
-------Računarski praktikum 3-------
43
Readonly varijable članice
Za razliku od konstanti koje se inicijaliziraju za vrijeme
kompiliranja, readonly varijable članice u klasi se
inicijaliziraju tijekom izvršavanja programa.
U sljedećem primjeru datum i vrijeme se ne može znati u
vrijeme kompiliranja.
public static readonly string currentDateTime =
DateTime.Now.ToString();
Napomena: DateTime je struktura, a Now je njezino statičko
read-only svojstvo.
09/04/2015
-------Računarski praktikum 3-------
44
Readonly varijable članice
class C
{
int a;
readonly int b;
public C(int i)
{
Console.WriteLine(a);
Console.WriteLine(b);
a = i;
b = i;
}
// 0
// 0
void PromijeniVrijednosti()
{
a += 3;
b -= 5;
// greška
}
}
09/04/2015
-------Računarski praktikum 3-------
45
Inicijalizatori objekata
Od C# 3.0 možemo koristiti inicijalizatore objekata. Pritom,
u vitičastim zagradama navodimo vrijednosti za (neke)
varijable članice, direktno ako su javne ili preko pripadnog
svojstva.
. Student s1= new Student { Ime=“Marko”, Prezime= “Horvat” };
// u ovom slučaju se prvo poziva konstruktor bez parametara, dakle
kompilator će javiti grešku ako nije definiran
Student s2= new Student (“Marko”) { Prezime=“Horvat” };
// ovdje je naravno potrebno imati definiran konstruktor klase Student
koji prima jedan string
09/04/2015
-------Računarski praktikum 3-------
46
Inicijalizatori objekata
Dakle, prvi primjer je ekvivalentan s .
Student s1= new Student();
s1.Ime=“Marko”;
s1.Prezime=“Horvat”;
Slično, možemo definirati i objekt anonimnog tipa:
var s3 = new { Ime = "Marko", Prezime = "Horvat" };
Console.WriteLine(s3.Ime);
s3.Prezime = "Markovic"; // greška, svojstvo je read-only
09/04/2015
-------Računarski praktikum 3-------
47
Metode
Metode su nespecijalizirane funkcije članice klase (ostale
funkcije čine konstruktori, finalizatori, svojstva, indekseri,
događaji i operatorske funkcije).
Za vraćanje podataka potrebno je specificirati povratni tip ili
koristiti ref/out parametre.
Potpis metode sastoji se od imena metode i tipova njezinih
parametara (ne uključuje povratni tip niti imena parametara).
Dozvoljeno je preopterećivanje metoda (postojanje više
metoda istog imena s različitim potpisom).
Razlika između out i ref modifikatora:
Out argumentu ne mora biti dodijeljena vrijednost prije
ulaska u metodu, ali mora prije izlaska iz metode.
09/04/2015
-------Računarski praktikum 3-------
48
Metode
Osnovni oblik je:
[ modifikator ] povratniTip ImeMetode( [ popis parametara ] )
{
tijelo metode
}
09/04/2015
-------Računarski praktikum 3-------
49
Modifikatori metode
09/04/2015
abstract
Poznat je samo potpis
metode, nema
implementacije.
extern
Potpis za vanjsku metodu
(pisanu u neupravljanom
kodu).
internal
Metoda je pristupačna na
razini asemblija.
new
Skriva metodu istog imena iz
bazne klase.
-------Računarski praktikum 3-------
50
Modifikatori metode
09/04/2015
override
Označava da metoda
nadjačava implementaciju
metode jednakog imena iz
bazne klase, virtualno
deklarirane ili da se radi o
implementaciji apstraktne
metode iz bazne klase.
private
Pristupačnost samo na razini
iste klase.
protected
Pristupačnost samo na razini
iste ili izvedene klase.
-------Računarski praktikum 3-------
51
Modifikatori metode
09/04/2015
static
Metoda se ne poziva na
instanci klase, koristi samo
statičke članove pripadne
klase.
virtual
Omogućava da metoda
može biti nadjačana u
izvedenim klasama.
-------Računarski praktikum 3-------
52
Prosljeđivanje argumenata
Argumenti mogu biti proslijeđeni metodi preko:
1.
Vrijednosnih parametara – pružaju metodi kopiju sebe,
dakle ne mijenja se originalna vrijednost
2.
Referentnih (ref) parametara – modificiranje parametra
unutar metode mijenja i originalnu varijablu koja mora
biti inicijalizirana prije ulaska u metodu.
3.
Izlaznih (out) parametara– ovi parametri ne moraju biti
inicijalizirani pri ulasku u metodu, ali moraju prije izlaska
iz metode (čak i ako su bili inicijalizirani prije ulaska).
Pokušaj pristupanja takvoj varijabli prije inicijalizacije u
metodi izaziva pogrešku pri kompiliranju.
09/04/2015
-------Računarski praktikum 3-------
53
Prosljeđivanje argumenata
4. Matričnih (params) parametara – omogućuju
prosljeđivanje niza vrijednosti u metodu.
void Metoda (int x);
void Metoda (ref int x);
void Metoda (out int x);
void Metoda (params int[ ] x);
Način prosljeđivanja argumenata također određuje potpis
metode (params nije dio potpisa). Nije ipak moguća
koegzistencija Metoda(ref int x) i Metoda (out int x).
09/04/2015
-------Računarski praktikum 3-------
54
Prosljeđivanje argumenata
class Program
{
static void Main(string[] args)
{
static void PovecajZaJedan(int a, ref int b, out int c)
{
++b;
c=++a;
}
int x=1, y=1, z, w=1;
PovecajZaJedan(x, ref y, out z);
PovecajZaDva(x, ref y, out w);
}
static void PovecajZaDva(int a, ref int b, out int c)
{
a += 2;
b += 2;
}
}
Zadatak: nađite grešku.
09/04/2015
-------Računarski praktikum 3-------
55
Prosljeđivanje argumenata
class Program
{
static void Main(string[] args)
{
static void PovecajZaJedan(int a, ref int b, out int c)
{
++b;
c=++a;
}
int x=1, y=1, z, w=1;
PovecajZaJedan(x, ref y, out z);
PovecajZaDva(x, ref y, out w);
}
static void PovecajZaDva(int a, ref int b, out int c)
{
a+ = 2;
Greška u funkciji
b += 2;
PovecajZaDva– parametru
}
c nije dodijeljena vrijednost
}
prije izlaska iz metode
09/04/2015
-------Računarski praktikum 3-------
56
Prosljeđivanje argumenata
Napomena: Prosljeđivanjem objekta referentnog tipa po
vrijednosti zapravo kopiramo referencu (ne i sam objekt).
Primjer: U sljedećem primjeru obje metode rade s istim
objektom. Prva metoda radi s kopijom reference (s), a druga
s originalnom referencom (student).
class Student
{
public string Ime;
……..
}
09/04/2015
-------Računarski praktikum 3-------
57
Prosljeđivanje argumenata
class Program
{
static void IspisiImePoVrijednosti(Student s)
{
Console.WriteLine(s.Ime);
s = null;
}
static void IspisiImePoReferenci(ref Student s)
{
Console.WriteLine(s.Ime);
s = null;
}
09/04/2015
-------Računarski praktikum 3-------
58
Prosljeđivanje argumenata
static void Main(string[] args)
{
Student student=new Student();
student.Ime="Karlo";
IspisiImePoVrijednosti(student);
Console.WriteLine(student.Ime);
IspisiImePoReferenci(ref student);
// Console.WriteLine(student.Ime);
}
}
09/04/2015
Ukoliko izbacimo komentar, izbacuje se
System.NullReferenceException.
-------Računarski praktikum 3-------
59
Prosljeđivanje argumenata
U sljedećem primjeru proslijedit ćemo vrijednosni tip po
referenci i analogan referentni tip po vrijednosti. Koristimo
prethodno definirane tipove:
class CPoint
{
public int X,Y;
}
struct SPoint
{
public int X,Y;
}
09/04/2015
-------Računarski praktikum 3-------
60
Prosljeđivanje argumenata
static void Main(string[] args)
{
SPoint struktura = new SPoint();
struktura.X = 2;
fs(ref struktura);
class Program
{
static void fs(ref SPoint sp)
{
sp = new SPoint();
}
CPoint klasa = new CPoint();
klasa.X = 2;
fc(klasa);
static void fc(CPoint cp)
{
cp = new CPoint();
}
Console.WriteLine(struktura.X);
Console.WriteLine(klasa.X);
}
}
09/04/2015
-------Računarski praktikum 3-------
61
Prosljeđivanje argumenata
static void Main(string[] args)
{
SPoint struktura = new SPoint();
struktura.X = 2;
fs(ref struktura);
class Program
{
static void fs(ref SPoint sp)
{
sp = new SPoint();
}
CPoint klasa = new CPoint();
klasa.X = 2;
fc(klasa);
static void fc(CPoint cp)
{
cp = new CPoint();
}
Console.WriteLine(struktura.X);
Console.WriteLine(klasa.X);
}
}
09/04/2015
// 0
// 2
-------Računarski praktikum 3-------
62
params
U listi parametara metode na zadnjem parametru možemo
navesti modifikator params. On označava da metoda može
primiti proizvoljan broj argumenata navedenog tipa. Tip tog
parametra mora biti tip polja.
static float Prosjek(params int[] ocjene)
{
int zbrojOcjena = 0;
for (int i = 0; i < ocjene.Length; ++i)
zbrojOcjena += ocjene[i];
Poziv funkcije:
float prosjek=
Prosjek(2, 3, 5, 4, 4);
return (float)zbrojOcjena/ocjene.Length;
}
09/04/2015
-------Računarski praktikum 3-------
63