using System;
Persona p = new Persona("Mario","Rossi");
Console.WriteLine(p.Denominazione);
struct Persona
{
private string nome;
private string cognome;
public Persona(string nome, string cognome)
{
this.nome = nome;
this.cognome = cognome;
}
public string Denominazione => this.nome + " " + this.cognome;
}
LE STRUCT IN C SHARP
Le struct in c sharp sono strutture simili alle classi, ma vi sono anche profonde differenze che tra un po’ analizzeremo. Una struct può contenere variabili, metodi, proprietà. La prima differenza che salta all’occhio guardando il codice sotto riportato è la parola chiave struct invece di class, ma analizziamo le differenze con le classi:
- La prima e quella più significativa è che le struct sono dei value types, a differenza delle classi che sono reference types.
- Le struct ammettono costruttori come le classi in cui inizializzare le variabili ma non hanno il costruttore senza parametri.
- Le struct non supportano l’ereditarietà, il secondo pilastro dopo l’incapsulamento della programmazione Object Oriented.
- Gli attributi delle struct devono essere esplicitamente inizializzati.
INIZIALIZZARE LE STRUCT
Definiamo una struttura che rappresenta il concetto di persona, con due attributi nome e cognome. Se da qualche altra parte del programma definiamo la struttura come Person p; abbiamo un piccolo problema, ossia i campi della Struct non sono inizializzati neanche ai loro valori di default. Siamo noi che dobbiamo esplicitamente inizializzarli. Nulla ci vieta di usare un costruttore con parametri per inizializzare tutti i campi della struct. Al termine di questi discorsi ci dobbiamo chiedere quando usare una struct oppure una classe? Una struct va bene per la definizione di dati semplici, non troppo articolati, ricordiamoci che è un Value Types, quindi se la struct deve essere passata come parametro ad un metodo se troppo grande si avrebbe una inefficienza in termini di occupazione di memoria.
I TIPI PRIMITIVI SONO DELLE STRUCT
Concludiamo l’argomento struct dicendo che tutti i tipi primitivi visti sinora ad eccezione di string sono delle struct, int è solo un alias mentre il vero nome della struttura è Int32. Dichiarare int x = 0; oppure Int32 x = 0; è perfettamente equivalente. Stesso discorso vale per gli altri tipi primitivi.
using System;
namespace Struct
{
class Program
{
static void Main(string[] args)
{
Azienda azienda = new Azienda("Pippo S.P.A",100,100_000_000); //INIZIALIZZAZIONE CON COSTRUTTORE
Azienda a = new Azienda();//VENGONO INIZIALIZZATI GLI ATTRIBUTI DELLA STRUCT AI LORO VALORI DI DEFAULT.
a.Fatturato=200_000_000m;
Persona persona; //LE VARIABILI DELLA STRUCT PERSONA NON SONO INIZIALIZZATE AI LORO VALORI DI DEFAULT
//A DIFFERENZA DELLE CLASSI.
persona.nome="Marco";
persona.cognome="Rossi";
//ESERCITAZIONE CON LE STRUCT
MyClass mc = new MyClass();
MyStruct ms = new MyStruct();
mc.eta=40;
mc.nome="Mario";
ms.eta=60;
ms.nome="Fabio";
Console.WriteLine($"Prima della chiamata mc.eta=: {mc.eta} ms.eta=: {ms.eta}");
MyMethod(mc,ms,"Pippo",20);
Console.WriteLine($"Dopo la chiamata mc.eta=: {mc.eta} ms.eta=: {ms.eta}");
/*--LE STRUCT ESSENDO DEI VALUE TYPES PASSANO AL METODO UNA COPIA DEI LORO ATTRIBUTI
AL RITORNO DAL METODO I VALORI NON SONO MODIFICATI. vICEVERSA LE CLASSI ESSENDO
DEI REFERENCE TYPES PASSANO UNA COPIA DEL RIFERIMENTO CHE PUNTA ALLA MEDESIMA STRUTTURA
CREATA NELL'HEAP, AL RITORNO L'ISTANZA mc SARA' MODIFICATA.*/
}
static void MyMethod(MyClass mc, MyStruct ms, string myString, int myInt )
{
mc.nome=myString;
mc.eta=myInt;
ms.nome=myString;
ms.eta=myInt;
}
}
public struct Azienda
{
private string ragioneSociale;
private int numeroDipendenti;
public decimal Fatturato {get;set;}
public Azienda(string ragioneSociale,int numeroDipendenti,decimal fatturato)
{
this.ragioneSociale=ragioneSociale;
this.numeroDipendenti=numeroDipendenti;
this.Fatturato=fatturato;
}
}
struct Persona
{
public string nome;
public string cognome;
}
public class MyClass
{
public string nome;
public int eta;
}
public struct MyStruct
{
public string nome;
public int eta;
}
}
APPROFONDIMENTO SULLE STRUCT
In C#, le strutture (struct) sono un tipo di dato che consente di creare tipi di dati complessi ma leggeri. Le strutture sono simili alle classi, ma ci sono alcune differenze chiave che le rendono più adatte per situazioni specifiche. Ecco una spiegazione semplice delle strutture in C#:
Cos’è una Struttura?
Una struttura è un tipo di dato che può contenere campi e metodi come una classe, ma è tipicamente usata per contenere un piccolo gruppo di dati correlati. Le strutture sono allocate nello stack, rendendole più efficienti per tipi di dati di piccole dimensioni.
Differenze tra Strutture e Classi
• Allocazione della memoria: Le strutture sono allocate nello stack mentre le classi sono allocate nell’heap.
• Immutabilità: Le strutture sono tipicamente immutabili (cioè i loro valori non cambiano dopo essere stati creati).
• Ereditarietà: Le strutture non possono essere derivate da altre strutture o classi (non supportano l’ereditarietà).
• Costruttore predefinito: Le strutture hanno un costruttore predefinito che non può essere rimosso.
Dichiarazione di una Struttura
Ecco un esempio di come dichiarare una struttura in C#:
public struct Punto
{
public int X;
public int Y;
public Punto(int x, int y)
{
X = x;
Y = y;
}
public void Muovi(int deltaX, int deltaY)
{
X += deltaX;
Y += deltaY;
}
public override string ToString()
{
return $”({X}, {Y})”;
}
}
Uso di una Struttura
Ecco come utilizzare la struttura Punto definita sopra:
class Program
{
static void Main()
{
Punto p = new Punto(2, 3);
Console.WriteLine(p); // Output: (2, 3)
p.Muovi(1, 1);
Console.WriteLine(p); // Output: (3, 4)
}
}
Caratteristiche delle Strutture
• Valore di tipo: Le strutture sono tipi di valore, quindi quando assegnate una struttura a un’altra, viene fatta una copia dei valori, non un riferimento.
• Costruttori: Le strutture possono avere costruttori per inizializzare i loro dati.
• Metodi e Proprietà: Le strutture possono avere metodi e proprietà come le classi.
• Interfacce: Le strutture possono implementare interfacce.
Quando Usare le Strutture?
•Quando si ha bisogno di un tipo di dati leggero.
•Quando si sa che il tipo di dati non cambierà dopo la sua creazione.
•Quando si vuole evitare l’overhead di allocazione dell’heap associato alle classi.
Le strutture sono ideali per rappresentare dati semplici come punti, rettangoli, colori, ecc., dove le prestazioni e l’efficienza della memoria sono cruciali.
Lascia un commento