Στην C#, οι μεταβλητές τύπου int αντιπροσωπεύουν έναν ακέραιο αριθμό (integer) και είναι ένας από τους πιο συχνά χρησιμοποιούμενους τύπους δεδομένων στη γλώσσα. Ακολουθούν κάποιες βασικές πληροφορίες και χαρακτηριστικά σχετικά με τις μεταβλητές τύπου int

1. Ορισμός και Δήλωση

Για να χρησιμοποιήσεις μια μεταβλητή τύπου int, πρέπει πρώτα να την δηλώσεις. Η δήλωση γίνεται με τον ακόλουθο τρόπο:

int myVariable;

Σε αυτό το παράδειγμα, myVariable είναι μια μεταβλητή τύπου int.

2. Αρχικοποίηση

Μπορείς να αρχικοποιήσεις μια μεταβλητή τύπου int κατά τη δήλωσή της ή αργότερα:

int myVariable = 10;

Εδώ, η myVariable έχει τιμή 10. Μπορείς επίσης να αλλάξεις την τιμή της αργότερα στον κώδικα:

myVariable = 20;

3. Εύρος τιμών

Ο τύπος int στην C# έχει εύρος τιμών από -2,147,483,648 έως 2,147,483,647. Αυτό σημαίνει ότι μπορεί να αποθηκεύσει οποιονδήποτε ακέραιο αριθμό μέσα σε αυτό το εύρος.

4. Μέγεθος μνήμης

Μια μεταβλητή τύπου int καταλαμβάνει 4 bytes (32 bits) μνήμης.

5. Χρήση

Οι μεταβλητές τύπου int χρησιμοποιούνται για την αποθήκευση ακέραιων τιμών χωρίς δεκαδικά ψηφία. Χρησιμοποιούνται συχνά σε βρόχους, μετρητές, ή οπουδήποτε χρειάζεται να εργαστείς με ακεραίους.

6. Παράδειγμα Χρήσης

using System;

class Program
{
    static void Main()
    {
        int myNumber = 42;
        Console.WriteLine("The number is: " + myNumber);
    }
}

Σε αυτό το παράδειγμα, δηλώνουμε μια μεταβλητή τύπου int με το όνομα myNumber, της δίνουμε την τιμή 42, και στη συνέχεια εκτυπώνουμε την τιμή της στην κονσόλα.

7. Λειτουργίες με int

Μπορείς να εκτελέσεις αριθμητικές πράξεις (π.χ. πρόσθεση, αφαίρεση, πολλαπλασιασμός, διαίρεση) μεταξύ μεταβλητών τύπου int:

int a = 5;
int b = 10;
int sum = a + b; // sum = 15

8. Περιορισμοί

Επειδή το int έχει συγκεκριμένο εύρος τιμών, πρέπει να είσαι προσεκτικός με υπολογισμούς που μπορεί να οδηγήσουν σε τιμές εκτός αυτού του εύρους, καθώς αυτό μπορεί να προκαλέσει σφάλμα υπερχείλισης (overflow).

Άλλοι Τύποι Ακέραιων (Integral Types)

Η C# παρέχει και άλλους τύπους ακεραίων που διαφέρουν ως προς το εύρος τους και το μέγεθος μνήμης που καταλαμβάνουν:

  • byte: 8-bit (0 έως 255)
  • sbyte: 8-bit (-128 έως 127)
  • short: 16-bit (-32,768 έως 32,767)
  • ushort: 16-bit (0 έως 65,535)
  • long: 64-bit (-9,223,372,036,854,775,808 έως 9,223,372,036,854,775,807)
  • ulong: 64-bit (0 έως 18,446,744,073,709,551,615)

Κατανοώντας τη διαφορά ανάμεσα σε αυτούς τους τύπους, μπορείς να επιλέξεις τον καταλληλότερο ανάλογα με τις ανάγκες της εφαρμογής σου, εξοικονομώντας μνήμη ή αποφεύγοντας σφάλματα υπερχείλισης.

1. Unsigned και Signed Τύποι

Οι τύποι int και long είναι signed, που σημαίνει ότι μπορούν να αποθηκεύσουν τόσο θετικές όσο και αρνητικές τιμές. Οι unsigned τύποι (π.χ. uint, ulong) μπορούν να αποθηκεύουν μόνο θετικές τιμές αλλά σε μεγαλύτερο εύρος, αφού δεν χρειάζεται να δεσμεύουν bits για την αποθήκευση του πρόσημου.

Φαντάσου ότι οι αριθμοί είναι κουτιά που μπορούν να αποθηκεύουν πράγματα. Ο κάθε τύπος αριθμού, όπως το int και το long, είναι ένα διαφορετικό μέγεθος κουτιού.

1. Signed τύποι (int, long)

Όταν λέμε ότι ένας αριθμός είναι “signed”, σημαίνει ότι μπορεί να αποθηκεύει είτε θετικούς αριθμούς (όπως +5) είτε αρνητικούς αριθμούς (όπως -5). Για να το κάνει αυτό, το κουτί πρέπει να κρατάει λίγο χώρο για να ξέρει αν ο αριθμός είναι θετικός ή αρνητικός. Αυτό το κάνουμε με τα “sign bits”.

Για παράδειγμα:

  • Ένα int είναι σαν ένα κουτί που μπορεί να αποθηκεύει αριθμούς από -2 δισεκατομμύρια έως +2 δισεκατομμύρια περίπου.
  • Ένα long είναι σαν ένα μεγαλύτερο κουτί που αποθηκεύει μεγαλύτερους αριθμούς, από -9 τετράκις εκατομμύρια έως +9 τετράκις εκατομμύρια περίπου.

Το πρόβλημα με τους signed αριθμούς είναι ότι χρειάζεται να “σπαταλήσουμε” μερικά από τα bits (χώρο στο κουτί) για να θυμόμαστε αν ο αριθμός είναι θετικός ή αρνητικός.

2. Unsigned τύποι (uint, ulong)

Από την άλλη πλευρά, οι unsigned τύποι είναι σαν κουτιά που αποθηκεύουν μόνο θετικούς αριθμούς. Δηλαδή, δεν χρειάζεται να κρατάνε χώρο για να ξέρουν αν ο αριθμός είναι θετικός ή αρνητικός, γιατί αποθηκεύουν μόνο θετικούς αριθμούς.

Για παράδειγμα:

  • Ένα uint (unsigned int) μπορεί να αποθηκεύει αριθμούς από 0 έως 4 δισεκατομμύρια περίπου.
  • Ένα ulong (unsigned long) μπορεί να αποθηκεύει αριθμούς από 0 έως 18 τετράκις εκατομμύρια περίπου.

Επειδή δεν χρειάζονται bits για το πρόσημο (sign), μπορούν να αποθηκεύουν μεγαλύτερους θετικούς αριθμούς σε σύγκριση με τους signed αριθμούς, χρησιμοποιώντας το ίδιο μέγεθος “κουτιού”.

Ας δούμε μερικά παραδείγματα για τους τύπους int, long, uint, και ulong για να καταλάβεις καλύτερα πώς λειτουργούν.

Παράδειγμα 1: Signed (int)

int a = -10;
int b = 20;
int c = a + b;
Console.WriteLine(c); // Αποτέλεσμα: 10

Εδώ, ο τύπος int μπορεί να αποθηκεύσει τόσο τον αρνητικό αριθμό -10 όσο και τον θετικό αριθμό 20. Όταν τα προσθέτουμε, το αποτέλεσμα είναι 10.

Παράδειγμα 2: Unsigned (uint)

uint a = 10;
uint b = 20;
uint c = a + b;
Console.WriteLine(c); // Αποτέλεσμα: 30

Σε αυτό το παράδειγμα, χρησιμοποιούμε τον τύπο uint που μπορεί να αποθηκεύει μόνο θετικούς αριθμούς (ή μηδέν). Η προσθήκη των αριθμών δίνει το αποτέλεσμα 30.

Σημαντικό: Δεν μπορούμε να χρησιμοποιήσουμε αρνητικούς αριθμούς εδώ. Αν προσπαθήσεις να γράψεις:

uint d = -5; // Λάθος!

Θα λάβεις σφάλμα, επειδή οι unsigned τύποι όπως το uint δεν επιτρέπουν αρνητικούς αριθμούς.

Παράδειγμα 3: Μεγαλύτεροι αριθμοί (long και ulong)

long (signed):

long bigNumber = 9223372036854775807; // Μέγιστος θετικός αριθμός για signed long
Console.WriteLine(bigNumber); // Αποτέλεσμα: 9223372036854775807

long negativeNumber = -9223372036854775808; // Μέγιστος αρνητικός αριθμός για signed long
Console.WriteLine(negativeNumber); // Αποτέλεσμα: -9223372036854775808

Το long επιτρέπει πολύ μεγαλύτερους αριθμούς, αλλά μπορεί να αποθηκεύει και αρνητικές τιμές.

ulong (unsigned):

ulong bigUnsignedNumber = 18446744073709551615; // Μέγιστος αριθμός για unsigned long

Console.WriteLine(bigUnsignedNumber); // Αποτέλεσμα: 18446744073709551615

Το ulong επιτρέπει να αποθηκεύεις ακόμη μεγαλύτερους αριθμούς, αλλά μόνο θετικούς (ή το μηδέν). Δεν μπορεί να αποθηκεύσει αρνητικούς αριθμούς, όπως είπαμε και πριν.

Παράδειγμα 4: Προβλήματα αν χρησιμοποιήσουμε λάθος τύπο

Αν προσπαθήσεις να αποθηκεύσεις έναν αριθμό μεγαλύτερο από το μέγιστο που επιτρέπεται, θα λάβεις σφάλμα ή “overflow” (υπερχείλιση).

int tooBig = 2147483648; // Σφάλμα! Ο αριθμός είναι πολύ μεγάλος για int

Το ίδιο συμβαίνει και με unsigned τύπους, αν προσπαθήσεις να αποθηκεύσεις αρνητικό αριθμό:

uint negativeNumber = -1; // Σφάλμα! Το uint δεν δέχεται αρνητικούς αριθμούς

2. Προεπιλεγμένη Τιμή

Οι μεταβλητές τύπου int που δηλώνονται χωρίς να αρχικοποιηθούν ρητά έχουν προεπιλεγμένη τιμή 0.

Φαντάσου ότι οι μεταβλητές στην C# είναι σαν κουτιά που μπορούν να αποθηκεύουν αριθμούς. Όταν δηλώνεις ένα κουτί (μια μεταβλητή τύπου int), αλλά δεν του λες αμέσως τι αριθμό να βάλει μέσα, η C# το γεμίζει αυτόματα με τον αριθμό 0. Αυτό σημαίνει ότι, αν δεν βάλεις εσύ κάτι μέσα, η C# βάζει από μόνη της 0.

Τι σημαίνει αυτό;

Αν δηλώσεις μια μεταβλητή τύπου int, χωρίς να της δώσεις τιμή, η τιμή της θα είναι 0. Αυτό γίνεται επειδή η C# θέλει να βεβαιωθεί ότι όλες οι μεταβλητές έχουν μια τιμή και δεν αφήνονται κενές.

Παράδειγμα:

Ας το δούμε αυτό με ένα παράδειγμα κώδικα:

int myNumber;  // Δηλώνω μια μεταβλητή τύπου int, αλλά δεν της δίνω τιμή
Console.WriteLine(myNumber);  // Αποτέλεσμα: 0

Σε αυτό το παράδειγμα:

  • Δηλώνουμε τη μεταβλητή myNumber χωρίς να της δώσουμε κάποιον αριθμό.
  • Όταν την εκτυπώνουμε, η C# μας δείχνει ότι η τιμή της είναι 0, γιατί αυτή είναι η προεπιλεγμένη τιμή για τις μεταβλητές τύπου int που δεν αρχικοποιούνται (δηλαδή δεν τους δίνουμε εμείς τιμή από την αρχή).

Άλλο Παράδειγμα:

int apples; // Δηλώνουμε τη μεταβλητή “apples” αλλά δεν της δίνουμε τιμή
apples = apples + 1; // Προσθέτουμε 1 στα μήλα
Console.WriteLine(apples); // Αποτέλεσμα: 1

Σε αυτό το παράδειγμα:

  • Δηλώνουμε τα apples (μήλα), αλλά δεν τους δίνουμε καμία τιμή. Επειδή δεν τους δώσαμε τιμή, η C# βάζει από μόνη της 0.
  • Στη συνέχεια προσθέτουμε 1 στα apples. Άρα το 0 (που έβαλε η C#) γίνεται 1.
  • Όταν το εκτυπώνουμε, το αποτέλεσμα είναι 1.

Γιατί είναι χρήσιμο;

Αυτό είναι πολύ χρήσιμο όταν θέλεις να δηλώσεις πολλές μεταβλητές και να τις χρησιμοποιήσεις αργότερα στον κώδικά σου, χωρίς να χρειάζεται να τις αρχικοποιείς όλες αμέσως. Η C# φροντίζει να μην είναι κενές και να ξεκινάνε από το 0.

Ανακεφαλαίωση:

  • Όταν δηλώνεις μια μεταβλητή τύπου int χωρίς να της δώσεις αμέσως τιμή, η C# βάζει 0 από μόνη της.
  • Αυτό βοηθά να μην έχεις ποτέ “κενές” μεταβλητές που μπορεί να προκαλέσουν προβλήματα στον κώδικά σου.

Έτσι, κάθε φορά που δεν ξέρεις τι τιμή να βάλεις αμέσως, η C# φροντίζει για σένα και βάζει 0. Είναι σαν να έχεις ένα άδειο κουτί που αρχικά το γεμίζεις με 0 μήλα και αργότερα μπορείς να προσθέσεις όσα μήλα θέλεις!

3. Μετατροπές Τύπου (Type Conversions)

Μπορείς να μετατρέψεις έναν ακέραιο τύπο σε άλλον μέσω ρητής μετατροπής (casting) ή με τη χρήση μεθόδων όπως Convert.ToInt32(). Πρέπει να είσαι προσεκτικός όταν μετατρέπεις από μεγαλύτερο σε μικρότερο τύπο για να αποφύγεις απώλεια δεδομένων ή σφάλματα

int myInt = 30000;
short myShort = (short)myInt; // Προσοχή: Ενδέχεται να χαθούν δεδομένα

Φαντάσου ότι οι αριθμοί είναι σαν κουτιά διαφορετικού μεγέθους. Ένα μικρό κουτί μπορεί να κρατήσει λίγα πράγματα, ενώ ένα μεγάλο κουτί μπορεί να κρατήσει περισσότερα πράγματα. Στην C#, όταν έχουμε αριθμούς, υπάρχουν διαφορετικά μεγέθη κουτιών (τύποι αριθμών) που μπορούν να κρατήσουν μεγαλύτερους ή μικρότερους αριθμούς.

Μετατροπή (Casting)

Μπορείς να αλλάξεις ένα νούμερο από ένα μεγάλο κουτί (μεγαλύτερο τύπο) σε ένα μικρότερο κουτί (μικρότερο τύπο), αλλά πρέπει να είσαι προσεκτικός, γιατί αν το νούμερο είναι πολύ μεγάλο για το μικρό κουτί, κάποια “πράγματα” μπορεί να χαθούν!

Αυτό ονομάζεται casting. Για να το κάνεις, χρησιμοποιείς παρενθέσεις και δηλώνεις σε ποιον τύπο θέλεις να μετατρέψεις τον αριθμό.

Παράδειγμα 1: Μετατροπή από μεγαλύτερο σε μικρότερο κουτί (casting)

int bigNumber = 12345; // Ένας αριθμός σε ένα “μεγάλο κουτί”
short smallNumber = (short)bigNumber; // Μετατρέπουμε το μεγάλο κουτί σε μικρότερο

Console.WriteLine(smallNumber); // Αποτέλεσμα: 12345 (το νούμερο χωράει, όλα καλά)

Εδώ:

  • Το int είναι ένα μεγαλύτερο κουτί που μπορεί να αποθηκεύσει μεγαλύτερους αριθμούς.
  • Το short είναι μικρότερο και μπορεί να κρατήσει μικρότερους αριθμούς.
  • Στο παράδειγμα, ο αριθμός 12345 είναι μικρός, οπότε χωράει στο μικρότερο κουτί και δεν έχουμε πρόβλημα.

Παράδειγμα 2: Μετατροπή με απώλεια δεδομένων

Αλλά, τι γίνεται αν ο αριθμός είναι πολύ μεγάλος για το μικρότερο κουτί

int bigNumber = 70000; // Ένας μεγάλος αριθμός
short smallNumber = (short)bigNumber; // Μετατρέπουμε σε μικρότερο κουτί (short)

Console.WriteLine(smallNumber); // Αποτέλεσμα: -25536 (αλλοιωμένος αριθμός)

Σε αυτό το παράδειγμα:

  • Το int μπορεί να αποθηκεύσει τον αριθμό 70000, αλλά το short δεν μπορεί να το κρατήσει γιατί είναι πολύ μικρό για αυτόν τον αριθμό.
  • Όταν προσπαθούμε να βάλουμε αυτόν τον μεγάλο αριθμό στο μικρότερο κουτί, χάνεται κομμάτι του αριθμού και το αποτέλεσμα δεν είναι σωστό, εμφανίζεται το -25536, που είναι αλλοιωμένος αριθμός.

Μετατροπή με τη χρήση της μεθόδου Convert.ToInt32()

Υπάρχει ένας άλλος τρόπος να μετατρέψεις αριθμούς με τη χρήση της μεθόδου Convert.ToInt32(). Αυτή η μέθοδος είναι σαν έναν τρόπο να ζητήσεις από την C# να κάνει τη μετατροπή για σένα, και θα προσπαθήσει να αποφύγει λάθη.

Παράδειγμα 3: Χρήση Convert.ToInt32()

double decimalNumber = 9.8; // Ένας αριθμός με δεκαδικά ψηφία
int wholeNumber = Convert.ToInt32(decimalNumber); // Μετατροπή σε ακέραιο (θα στρογγυλέψει)

Console.WriteLine(wholeNumber); // Αποτέλεσμα: 10

Σε αυτό το παράδειγμα:

  • Έχουμε έναν δεκαδικό αριθμό (9.8).
  • Χρησιμοποιούμε το Convert.ToInt32() για να τον μετατρέψουμε σε ακέραιο αριθμό. Η μέθοδος αυτή στρογγυλεύει τον αριθμό στο κοντινότερο ακέραιο, γι’ αυτό το αποτέλεσμα είναι 10.

Προσοχή όταν μετατρέπεις μεγάλους αριθμούς

Όταν μετατρέπεις από ένα μεγαλύτερο τύπο (π.χ. long) σε έναν μικρότερο τύπο (π.χ. int), πρέπει να είσαι προσεκτικός. Αν ο αριθμός είναι πολύ μεγάλος για τον μικρότερο τύπο, θα χάσεις δεδομένα ή θα έχεις λάθος αποτέλεσμα, όπως είδαμε στο παράδειγμα με το short.

Ανακεφαλαίωση:

  • Casting: Χρησιμοποιούμε παρενθέσεις για να αλλάξουμε τον τύπο του αριθμού. Προσοχή όμως, γιατί αν ο αριθμός δεν χωράει στον νέο τύπο, μπορεί να χάσεις δεδομένα.
  • Convert.ToInt32(): Μπορεί να χρησιμοποιηθεί για να κάνεις μετατροπές με μεγαλύτερη ασφάλεια, όπως για παράδειγμα στρογγυλοποίηση όταν μετατρέπεις δεκαδικούς αριθμούς σε ακέραιους.

4. Overflow και Underflow

Όταν μια αριθμητική πράξη ξεπερνά το μέγιστο ή ελάχιστο επιτρεπτό εύρος τιμών ενός τύπου, προκαλείται υπερχείλιση (overflow) ή υποχείλιση (underflow). Η C# προσφέρει δύο τρόπους χειρισμού αυτών των καταστάσεων:

  • Unchecked: Αφήνει την υπερχείλιση να συμβεί, τυλίγοντας τον αριθμό.
  • Checked: Παράγει μια εξαίρεση OverflowException αν συμβεί υπερχείλιση.
checked
{
    int maxInt = int.MaxValue;
    int overflowInt = maxInt + 1; // Θα προκαλέσει OverflowException
}

Τι είναι η υπερχείλιση (overflow) και η υποχείλιση (underflow);

Φαντάσου ότι οι αριθμοί είναι σαν ένα καλάθι που μπορεί να γεμίσει με καραμέλες. Κάθε τύπος αριθμού στην C# (όπως το int ή το byte) έχει ένα όριο στο πόσες καραμέλες μπορεί να χωρέσει το καλάθι.

  • Υπερχείλιση (overflow) συμβαίνει όταν προσπαθείς να βάλεις πάρα πολλές καραμέλες (δηλαδή έναν πολύ μεγάλο αριθμό) σε ένα καλάθι και αυτό γεμίζει τόσο πολύ που ξεχειλίζει. Αντί να σπάσει το καλάθι, ο αριθμός “τυλίγεται” και γίνεται κάτι παράξενο.
  • Υποχείλιση (underflow) συμβαίνει όταν αφαιρείς πολλές καραμέλες από το καλάθι και προσπαθείς να το κάνεις να έχει αρνητικά καραμέλες, αλλά το καλάθι δεν μπορεί να το καταλάβει και κάτι πάει στραβά.

Unchecked: Αφήνει την υπερχείλιση να συμβεί

Όταν μια υπερχείλιση συμβαίνει σε κατάσταση unchecked, η C# επιτρέπει να συμβεί και δεν σε προειδοποιεί. Αυτό σημαίνει ότι αν ο αριθμός ξεπεράσει το μέγιστο όριο, “τυλίγεται” και αρχίζει από το ελάχιστο όριο.

Παράδειγμα 1: Unchecked υπερχείλιση (overflow)

int maxNumber = int.MaxValue; // Το μεγαλύτερο νούμερο που μπορεί να αποθηκεύσει το int
int result = maxNumber + 1; // Προσθέτουμε 1 και ξεπερνάμε το όριο

Console.WriteLine(result); // Αποτέλεσμα: -2147483648 (τυλίγεται και γίνεται αρνητικός!)

Τι συνέβη εδώ;

  • Το int.MaxValue είναι το μεγαλύτερο νούμερο που μπορεί να αποθηκεύσει ένα int (2147483647).
  • Όταν προσθέτουμε 1 σε αυτό, ξεπερνάμε το όριο και αντί να λάβουμε σφάλμα, ο αριθμός “τυλίγεται” και γίνεται ένας αρνητικός αριθμός, -2147483648.

Αυτό είναι σαν να προσπαθείς να βάλεις μία ακόμα καραμέλα σε ένα γεμάτο καλάθι και, αντί να πέσει έξω, αυτή εμφανίζεται ξαφνικά στο κάτω μέρος του καλαθιού σαν να “τυλίγεται”.

Checked: Προκαλεί σφάλμα όταν συμβεί υπερχείλιση

Όταν χρησιμοποιούμε την κατάσταση checked, η C# προσέχει προσεκτικά και αν δει ότι ξεπερνάς το όριο, σου δείχνει ένα μήνυμα σφάλματος (εξαίρεση OverflowException). Είναι σαν να σε προειδοποιεί: “Ωπ, το καλάθι είναι γεμάτο! Δεν μπορώ να βάλω άλλες καραμέλες εδώ!”

Παράδειγμα 2: Checked υπερχείλιση (overflow)

try
{
int maxNumber = int.MaxValue; // Το μεγαλύτερο νούμερο για int
int result = checked(maxNumber + 1); // Προσθέτουμε 1 με έλεγχο για υπερχείλιση
Console.WriteLine(result); // Δεν θα εκτελεστεί γιατί θα πετάξει σφάλμα
}
catch (OverflowException ex)
{
Console.WriteLine(“Υπερχείλιση! Δεν μπορούμε να προσθέσουμε άλλο.”); // Προειδοποίηση για υπερχείλιση
}

Τι συνέβη εδώ;

  • Προσθέσαμε 1 στο int.MaxValue, αλλά αυτή τη φορά με checked.
  • Όταν η C# είδε ότι θα συμβεί υπερχείλιση, πέταξε ένα σφάλμα (OverflowException) και δεν άφησε τον αριθμό να τυλιχτεί.
  • Έτσι, εμφανίστηκε το μήνυμα “Υπερχείλιση! Δεν μπορούμε να προσθέσουμε άλλο.”

Γιατί να χρησιμοποιήσεις checked;

Το checked είναι χρήσιμο όταν δεν θέλεις οι αριθμοί να τυλίγονται και να γίνονται λάθη χωρίς να το καταλάβεις. Είναι σαν να έχεις έναν προειδοποιητικό μηχανισμό που σου λέει: “Κάτι πάει στραβά!”

Ανακεφαλαίωση:

  • Unchecked: Όταν η υπερχείλιση συμβαίνει, ο αριθμός “τυλίγεται” και δεν εμφανίζεται σφάλμα. Μπορεί να έχεις αριθμούς που φαίνονται παράξενοι (π.χ. αρνητικοί).
  • Checked: Όταν η υπερχείλιση συμβαίνει, η C# σταματάει και σου λέει ότι υπάρχει πρόβλημα, ρίχνοντας μια εξαίρεση (OverflowException).

Φαντάσου ότι το unchecked είναι σαν να αφήνεις το καλάθι να ξεχειλίζει χωρίς να το προσέχεις, ενώ το checked είναι σαν να έχεις έναν φρουρό που σου λέει όταν το καλάθι είναι γεμάτο, ώστε να μη συμβεί τίποτα παράξενο.

5. Bitwise Πράξεις

Οι μεταβλητές τύπου int υποστηρίζουν bitwise πράξεις (π.χ. AND, OR, XOR, μετατοπίσεις) που επιτρέπουν άμεση διαχείριση των bits της μεταβλητής. Αυτές οι πράξεις είναι χρήσιμες σε καταστάσεις όπου χρειάζεται να εργαστείς σε χαμηλό επίπεδο με bits, όπως για βελτιστοποίηση της απόδοσης ή σε κρυπτογραφικούς αλγορίθμους.

int a = 5; // 0101 σε binary
int b = 3; // 0011 σε binary
int result = a & b; // 0001 σε binary, δηλαδή 1

Τι είναι τα bits;

Φαντάσου ότι κάθε αριθμός στον υπολογιστή είναι φτιαγμένος από μικροσκοπικά κουτάκια που λέγονται bits. Κάθε κουτάκι μπορεί να είναι είτε 0 (άδειο) είτε 1 (γεμάτο). Ένας αριθμός, όπως το 5 ή το 10, αποτελείται από πολλά τέτοια κουτάκια το ένα δίπλα στο άλλο.

Για παράδειγμα:

  • Ο αριθμός 5 σε bits είναι: 00000101
  • Ο αριθμός 10 σε bits είναι: 00001010

Τα bits είναι σαν τα μικρότερα κομμάτια ενός αριθμού στον υπολογιστή.

Τι είναι οι bitwise πράξεις;

Οι bitwise πράξεις είναι σαν εργαλεία που σου επιτρέπουν να δουλέψεις απευθείας με αυτά τα μικροσκοπικά κουτάκια (bits) για να κάνεις διάφορες αλλαγές στους αριθμούς. Αυτά τα εργαλεία επιτρέπουν να συγκρίνεις, να συνδυάσεις, ή να μετακινήσεις αυτά τα κουτάκια με συγκεκριμένο τρόπο.

Υπάρχουν πολλές bitwise πράξεις που μπορείς να κάνεις, όπως:

  1. AND (Και) &: Κρατάει μόνο τα bits που είναι γεμάτα (1) και στα δύο κουτάκια.
  2. OR (Ή) |: Κρατάει τα bits που είναι γεμάτα (1) είτε στο ένα κουτάκι είτε στο άλλο.
  3. XOR (Αποκλειστικό Ή) ^: Κρατάει τα bits που είναι γεμάτα (1) μόνο σε ένα από τα δύο κουτάκια, αλλά όχι και στα δύο.
  4. Μετατοπίσεις (Shifts): Μετακινείς τα bits αριστερά ή δεξιά, σαν να μετακινείς τα κουτάκια.

Παράδειγμα 1: Πράξη AND

Η πράξη AND συγκρίνει δύο αριθμούς bit-bit και κρατάει το 1 μόνο αν και οι δύο αριθμοί έχουν 1 στην ίδια θέση. Ας δούμε ένα παράδειγμα:

int a = 5; // Σε bits: 00000101
int b = 3; // Σε bits: 00000011
int result = a & b; // AND πράξη

Console.WriteLine(result); // Αποτέλεσμα: 1 (Σε bits: 00000001)

Τι έγινε εδώ;

  • Ο αριθμός 5 είναι 00000101 σε bits.
  • Ο αριθμός 3 είναι 00000011 σε bits.
  • Κάνοντας πράξη AND, συγκρίνουμε κάθε bit. Μόνο στην τελευταία θέση και οι δύο αριθμοί έχουν 1, οπότε το αποτέλεσμα είναι 00000001 (που είναι 1).

Παράδειγμα 2: Πράξη OR

Η πράξη OR συγκρίνει δύο αριθμούς και κρατάει το 1 αν οποιοδήποτε από τα bits είναι 1. Ας το δούμε:

int a = 5; // Σε bits: 00000101
int b = 3; // Σε bits: 00000011
int result = a | b; // OR πράξη

Console.WriteLine(result); // Αποτέλεσμα: 7 (Σε bits: 00000111)

Τι έγινε εδώ;

  • Ο αριθμός 5 είναι 00000101.
  • Ο αριθμός 3 είναι 00000011.
  • Με την πράξη OR, κρατάμε το 1 όπου υπάρχει τουλάχιστον ένα 1. Το αποτέλεσμα είναι 00000111 (που είναι 7).

Παράδειγμα 3: Πράξη XOR

Η πράξη XOR συγκρίνει δύο αριθμούς και κρατάει το 1 μόνο αν τα bits είναι διαφορετικά. Αν είναι και τα δύο ίδια (0 ή 1), βάζει 0.

int a = 5; // Σε bits: 00000101
int b = 3; // Σε bits: 00000011
int result = a ^ b; // XOR πράξη

Console.WriteLine(result); // Αποτέλεσμα: 6 (Σε bits: 00000110)

Τι έγινε εδώ;

  • Ο αριθμός 5 είναι 00000101.
  • Ο αριθμός 3 είναι 00000011.
  • Με την πράξη XOR, το αποτέλεσμα είναι 1 μόνο όταν τα bits είναι διαφορετικά. Έτσι παίρνουμε 00000110 (που είναι 6).

Παράδειγμα 4: Μετατοπίσεις (Shifts)

Μπορούμε να μετακινήσουμε τα bits αριστερά ή δεξιά με τις μετατοπίσεις. Αυτό είναι σαν να μετακινείς όλα τα κουτάκια μία θέση αριστερά ή δεξιά.

  • Αριστερή μετατόπιση (Left Shift) <<: Μετακινεί τα bits αριστερά και προσθέτει 0 στα δεξιά.
  • Δεξιά μετατόπιση (Right Shift) >>: Μετακινεί τα bits δεξιά και προσθέτει 0 στα αριστερά.

int a = 5; // Σε bits: 00000101
int result = a << 1; // Αριστερή μετατόπιση κατά 1 θέση

Console.WriteLine(result); // Αποτέλεσμα: 10 (Σε bits: 00001010)

Τι έγινε εδώ;

  • Ο αριθμός 5 είναι 00000101.
  • Όταν τον μετατοπίζουμε αριστερά κατά μία θέση, γίνεται 00001010 (που είναι 10).

Γιατί είναι χρήσιμες οι bitwise πράξεις;

Οι bitwise πράξεις είναι χρήσιμες όταν θέλεις να δουλέψεις απευθείας με τα bits ενός αριθμού, κάτι που είναι πολύ γρήγορο για τον υπολογιστή. Είναι χρήσιμες σε καταστάσεις όπως:

  • Κρυπτογραφία: Για να κρυπτογραφήσεις και να αποκρυπτογραφήσεις δεδομένα.
  • Βελτιστοποίηση απόδοσης: Όταν θέλεις ο κώδικας να τρέχει πολύ γρήγορα και να καταλαμβάνει λίγο χώρο.
  • Χειρισμός δεδομένων σε χαμηλό επίπεδο: Όπως το να διαβάζεις ή να γράφεις συγκεκριμένα bits από αισθητήρες ή hardware.

Ανακεφαλαίωση:

  • Bitwise AND (&): Κρατάει το 1 μόνο αν και οι δύο αριθμοί έχουν 1 στην ίδια θέση.
  • Bitwise OR (|): Κρατάει το 1 αν οποιοδήποτε από τα bits είναι 1.
  • Bitwise XOR (^): Κρατάει το 1 μόνο αν τα bits είναι διαφορετικά.
  • Μετατοπίσεις (<< και >>): Μετακινούν τα bits αριστερά ή δεξιά.

Αυτές οι πράξεις είναι σαν να έχεις μικρά κουτάκια και να μπορείς να τα μετακινήσεις, να τα συγκρίνεις ή να τα συνδυάσεις με διάφορους τρόπους, κάτι που είναι πολύ χρήσιμο όταν δουλεύεις με αριθμούς σε χαμηλό επίπεδο στον υπολογιστή!

6. Σταθερές (Constants)

Μπορείς να χρησιμοποιήσεις τη λέξη-κλειδί const για να δηλώσεις μια σταθερή τιμή τύπου int, η οποία δεν μπορεί να αλλάξει κατά την εκτέλεση του προγράμματος.

const int maxStudents = 30;

Τι είναι το const στην C#;

Φαντάσου ότι έχεις ένα κουτί με καραμέλες, και το γεμίζεις με έναν συγκεκριμένο αριθμό καραμελών. Αν βάλεις την ετικέτα const στο κουτί, αυτό σημαίνει ότι δεν μπορείς ποτέ να αλλάξεις τον αριθμό των καραμελών μέσα στο κουτί. Ο αριθμός αυτός θα μείνει για πάντα ο ίδιος!

Στην C#, όταν χρησιμοποιούμε τη λέξη-κλειδί const (που σημαίνει “σταθερό”), λέμε στον υπολογιστή ότι μια τιμή δεν πρόκειται ποτέ να αλλάξει μόλις την ορίσουμε.

Γιατί είναι χρήσιμο;

  • Είναι χρήσιμο όταν έχουμε τιμές που δεν πρόκειται να αλλάξουν ποτέ στο πρόγραμμα μας, όπως για παράδειγμα ο αριθμός των ωρών σε μια μέρα (24).
  • Χρησιμοποιούμε το const για να είμαστε σίγουροι ότι κάποιος κατά λάθος δεν θα αλλάξει αυτή την τιμή στο μέλλον.

Πώς το χρησιμοποιούμε;

Η σύνταξη για να δηλώσεις μια σταθερή τιμή είναι πολύ απλή. Απλά γράφεις τη λέξη const πριν από τον τύπο της μεταβλητής και τη δίνεις την τιμή που δεν θα αλλάξει.

Παράδειγμα:

const int daysInWeek = 7;  // Υπάρχουν πάντα 7 ημέρες την εβδομάδα
Console.WriteLine(daysInWeek);  // Αποτέλεσμα: 7

Σε αυτό το παράδειγμα:

  • Δηλώνουμε μια σταθερή μεταβλητή daysInWeek που θα είναι πάντα ίση με 7.
  • Αν προσπαθήσεις να αλλάξεις την τιμή της, θα λάβεις σφάλμα.

Παράδειγμα με σφάλμα:

Ας πούμε ότι προσπαθείς να αλλάξεις την τιμή της σταθερής μετά από τη δήλωσή της:

const int daysInWeek = 7;
daysInWeek = 5; // Σφάλμα! Δεν μπορείς να αλλάξεις την τιμή μιας σταθεράς

Τι έγινε εδώ;

  • Η C# θα σου δείξει σφάλμα, γιατί προσπαθείς να αλλάξεις την τιμή μιας σταθερής μεταβλητής, κάτι που δεν επιτρέπεται!

Πλεονεκτήματα του const:

  • Σε βοηθάει να γράφεις ασφαλή κώδικα, γιατί ξέρεις ότι συγκεκριμένες τιμές δεν θα αλλάξουν ποτέ.
  • Ο υπολογιστής σου μπορεί να τρέξει πιο γρήγορα, γιατί γνωρίζει από την αρχή ότι η τιμή δεν θα αλλάξει ποτέ.

Ανακεφαλαίωση:

  • Η λέξη-κλειδί const χρησιμοποιείται για να δηλώσεις σταθερές τιμές που δεν αλλάζουν ποτέ κατά τη διάρκεια του προγράμματος.
  • Αν προσπαθήσεις να αλλάξεις μια σταθερή τιμή, θα λάβεις σφάλμα.
  • Είναι χρήσιμο για τιμές που δεν αλλάζουν ποτέ, όπως το 7 ημέρες την εβδομάδα ή το 24 ώρες σε μια μέρα.

Παράδειγμα με πολλαπλές σταθερές:

const int hoursInDay = 24;
const int minutesInHour = 60;

int totalMinutesInDay = hoursInDay * minutesInHour;
Console.WriteLine(totalMinutesInDay); // Αποτέλεσμα: 1440

Σε αυτό το παράδειγμα:

  • Δηλώνουμε δύο σταθερές: hoursInDay και minutesInHour.
  • Υπολογίζουμε πόσα λεπτά υπάρχουν σε μια μέρα, και επειδή οι τιμές είναι σταθερές, το πρόγραμμα ξέρει ότι πάντα θα υπάρχουν 1440 λεπτά σε μία μέρα.

7. Χρήση σε Βρόχους και Υπολογισμούς

Οι μεταβλητές τύπου int χρησιμοποιούνται συχνά σε βρόχους για τον έλεγχο της επανάληψης:

for (int i = 0; i < 10; i++) { Console.WriteLine(i); }

Σε βρόχους και άλλες μαθηματικές διαδικασίες, η κατανόηση του τρόπου με τον οποίο οι μεταβλητές int επηρεάζουν την απόδοση και τον χώρο μνήμης μπορεί να σε βοηθήσει να γράψεις πιο αποδοτικό κώδικα.

Τι είναι ένας βρόχος (loop) στην C#;

Φαντάσου ότι θέλεις να κάνεις το ίδιο πράγμα ξανά και ξανά, όπως να μετρήσεις από το 1 μέχρι το 10 ή να φας ένα κουτί με καραμέλες μία-μία. Αντί να γράφεις τον ίδιο κώδικα πολλές φορές, μπορείς να χρησιμοποιήσεις έναν βρόχο! Ο βρόχος είναι σαν να λες στον υπολογιστή “κάνε αυτό το πράγμα ξανά και ξανά μέχρι να σου πω να σταματήσεις.”

Πώς χρησιμοποιούνται οι μεταβλητές int στους βρόχους;

Οι μεταβλητές τύπου int είναι συχνά πολύ χρήσιμες στους βρόχους για να μετρούν πόσες φορές πρέπει να επαναληφθεί κάτι. Η int μεταβλητή είναι σαν ένα “μετρητή” που κρατάει τον αριθμό της επανάληψης.

Τι είναι ο for βρόχος;

Ο for βρόχος είναι ένας τύπος βρόχου στην C# που λέει στον υπολογιστή:

  • Από πού να ξεκινήσει να μετράει.
  • Πότε να σταματήσει να μετράει.
  • Πόσο να αυξάνει το μέτρημα κάθε φορά.

Πώς δουλεύει ο for βρόχος;

Ας δούμε ένα παράδειγμα για να καταλάβεις πώς δουλεύει:

for (int i = 0; i < 10; i++) {
Console.WriteLine(i);
}

Τι σημαίνει αυτό;

  • int i = 0: Ξεκινάμε από το 0. Ο αριθμός i είναι η “μεταβλητή μετρητής” και είναι τύπου int.
  • i < 10: Ο βρόχος θα συνεχίσει να επαναλαμβάνεται όσο ο αριθμός i είναι μικρότερος από 10.
  • i++: Κάθε φορά που ολοκληρώνεται μια επανάληψη, ο αριθμός i αυξάνεται κατά 1.

Αυτό σημαίνει ότι ο υπολογιστής θα εκτυπώσει τους αριθμούς από 0 μέχρι 9, επειδή μόλις το i γίνει 10, ο βρόχος σταματάει.

Πώς λειτουργεί;

  1. Ο βρόχος ξεκινά με το i = 0.
  2. Ελέγχει αν το i είναι μικρότερο από 10. Αν ναι, μπαίνει στον βρόχο.
  3. Εκτυπώνει τον αριθμό i.
  4. Αυξάνει το i κατά 1.
  5. Ξεκινά πάλι από την αρχή μέχρι το i να φτάσει το 10.

Παράδειγμα εξήγησης:

Φαντάσου ότι έχεις μια σειρά από 10 κουτιά με καραμέλες και θέλεις να ανοίξεις το καθένα ξεχωριστά και να δεις πόσες καραμέλες έχει μέσα.

  • Το i είναι σαν ένας αριθμός που δείχνει ποιο κουτί ανοίγεις τώρα.
  • Ξεκινάς από το i = 0, ανοίγεις το κουτί 0, μετά αυξάνεις το i σε 1, ανοίγεις το επόμενο κουτί, και συνεχίζεις έτσι μέχρι να φτάσεις στο 9ο κουτί.
  • Όταν φτάσεις στο κουτί με αριθμό 10, σταματάς, γιατί έχεις ανοίξει όλα τα κουτιά από 0 έως 9.

Παράδειγμα με for βρόχο:

for (int i = 1; i <= 5; i++) {
Console.WriteLine(“Ανοίγω το κουτί ” + i);
}

Τι σημαίνει αυτό;

  • int i = 1: Ξεκινάς από το 1.
  • i <= 5: Συνεχίζεις μέχρι το i να γίνει 5 (δηλαδή θα ανοίξεις 5 κουτιά).
  • i++: Κάθε φορά αυξάνεις το i κατά 1.

Το πρόγραμμα θα εκτυπώσει:

Ανοίγω το κουτί 1
Ανοίγω το κουτί 2
Ανοίγω το κουτί 3
Ανοίγω το κουτί 4
Ανοίγω το κουτί 5

Γιατί είναι χρήσιμος ο βρόχος με το int;

Οι μεταβλητές τύπου int είναι χρήσιμες στους βρόχους γιατί μας βοηθάνε να μετράμε πόσες φορές θέλουμε να κάνουμε κάτι. Έτσι, μπορούμε να επαναλάβουμε μια ενέργεια όσες φορές θέλουμε, χωρίς να χρειάζεται να γράψουμε τον ίδιο κώδικα πολλές φορές.

Ανακεφαλαίωση:

  • Ο for βρόχος χρησιμοποιεί μια μεταβλητή int για να μετράει πόσες φορές θα επαναληφθεί κάτι.
  • Ο αριθμός αυτός ξεκινά από μια τιμή (π.χ. 0), αυξάνεται κάθε φορά (π.χ. i++), και σταματά όταν φτάσει σε μια συγκεκριμένη τιμή (π.χ. i < 10).
  • Οι βρόχοι μας βοηθάνε να εκτελούμε τον ίδιο κώδικα πολλές φορές εύκολα.

Είναι σαν να λες στον υπολογιστή: “Άνοιξε αυτά τα κουτιά το ένα μετά το άλλο, και πες μου πόσα έχεις ανοίξει!”