public static void Executar()
{
// struct:
SPonto ponto1 = new SPonto
{
X = 1,
Y = 3
};
SPonto copiaPonto1 = ponto1; // Atribuição por valor, Uma cópia do valor é atribuido para variável, se eu alterar 1 não gera alteração no outro, pois não compartilham a mesma memória. Isto só acontece por que SPonto é um struct.
ponto1.X = 3;
Console.WriteLine("Ponto 1 X: {0}", ponto1.X);
Console.WriteLine("Cópia Ponto 1 X: {0}", copiaPonto1.X);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// class:
CPonto ponto2 = new CPonto
{
X = 2,
Y = 4
};
CPonto copiaPonto2 = ponto2; // Atribuição por Referência. Abos compartilham do mesmo local de memória, se alterar 1 o outo também sofre alteração.
ponto2.X = 4;
Console.WriteLine("Ponto 2 X: {0}", ponto2.X);
Console.WriteLine("Cópia Ponto 2 X: {0}", copiaPonto2.X);
}
public static void Executar()
{
// STRUCT:
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; // ATRIBUIÇÃO POR VALOR, NÃO REFERÊNCIA!!!
ponto1.X = 3;
// Os valores ficam diferentes:
Console.WriteLine("Ponto 1 X: {0}", ponto1.X);
Console.WriteLine("Cópia Ponto 1 X: {0}", copiaPonto1.X);
// CLASSE:
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; // ATRIBUIÇÃO POR REFERÊNCIA, NÃO VALOR!!!
ponto2.X = 4;
// OS VALORES APONTAM PARA O MESMO LOCAL DE MEMÓRIA,
// POR ISSO SE MUDAR EM UM LOCAL MUDA NO OUTRO
Console.WriteLine("Ponto 2 X: {0}", ponto2.X);
Console.WriteLine("Cópia do Ponto 2 X: {0}", copiaPonto2.X);
}
public static void Executar()
{
//Struct faz Atribuição por VALOR:
Console.WriteLine("\nSTRUCT = Atribuição por VALOR \n");
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
Console.WriteLine($"Valor do Ponto 1 = X: {ponto1.X} Y: {ponto1.Y}");
SPonto copyPonto1 = ponto1;
ponto1.X = 3;
Console.WriteLine($"Valor do Ponto 1 = X: {ponto1.X} Y: {ponto1.Y}");
Console.WriteLine($"Valor de CopyPonto 1 = X: {copyPonto1.X} Y: {copyPonto1.Y}");
//Class faz Atribuição por REFERÊNCIA:
Console.WriteLine("\nCLASS = Atribuição por REFERÊNCIA \n");
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
Console.WriteLine($"Valor do Ponto 1 = X: {ponto2.X} Y: {ponto2.Y}");
CPonto copyPonto2 = ponto2;
ponto2.X = 5;
Console.WriteLine($"Valor do Ponto 1 = X: {ponto2.X} Y: {ponto2.Y}");
Console.WriteLine($"Valor de CopyPonto 1 = X: {copyPonto2.X} Y: {copyPonto2.Y}");
} //fim do executar.
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; //Atribuição por VALOR!!
ponto1.X = 3;
Console.WriteLine("Ponto 1 X: {0}", ponto1.X);
Console.WriteLine("Copia Ponto 1 X: {0}", copiaPonto1.X);
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; //Atribuição por REFERÊNCIA!!
ponto2.X = 4;
Console.WriteLine("Ponto 2 X: {0}", ponto2.X);
Console.WriteLine("Copia Ponto 2 X: {0}", copiaPonto2.X);
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; // Atribuição por valor
ponto1.X = 3;
Console.WriteLine("Ponto 1 X: " + ponto1.X);
Console.WriteLine("Cópia Ponto 1 X: " + copiaPonto1.X);
CPonto ponto2 = new CPonto {
X = 1, Y = 3
};
CPonto copiaCPonto2 = ponto2;
ponto2.X = 5;
Console.WriteLine("Ponto 1 X: " + ponto2.X);
Console.WriteLine("Cópia Ponto 1 X: " + copiaCPonto2.X);
}
public static void Executar()
{
SPonto p1 = new SPonto {
X = 1, Y = 3
};
SPonto cpp1 = p1; //Atribuição por valor, portanto será uma atribuição onde serão gerados 2 endereços de memorias e cada objeto aponta para um endereço.
p1.X = 3;
Console.WriteLine($"P1 X: {p1.X}");
Console.WriteLine($"P1 Copia X: {cpp1.X}");
CPonto p2 = new CPonto {
X = 2, Y = 3
};
CPonto cpp2 = p2; //Atribuição por referencia, portanto os 2 objetos apontaram para o mesmo endereço de memória, portanto se alterar em um objeto o outro tbm será alterado.
p2.X = 4;
Console.WriteLine($"P1 X: {p2.X}");
Console.WriteLine($"P1 Copia X: {cpp2.X}");
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; // Atribuição por valor
ponto1.X = 3;
Console.WriteLine("Ponto 1 X:{0}", ponto1.X);
Console.WriteLine("Cópia Ponto 1 X:{0}", copiaPonto1.X);
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; // Atribuição por referência
ponto2.X = 4;
Console.WriteLine("Ponto 2 X:{0}", ponto2.X);
Console.WriteLine("Cópia Ponto 2 X:{0}", ponto2.X);
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 2
};
SPonto copiaSPonto = ponto1;
ponto1.X = 10;
Console.WriteLine("O valor do ponto é {0}", ponto1.X); // É 10 FOI INSTANCIADO
Console.WriteLine("O valor do ponto é {0}", copiaSPonto.X); // Atribuição por valor
CPonto cponto1 = new CPonto {
X = 2, Y = 20
};
CPonto copiaCPonto1 = cponto1;
cponto1.X = 22;
Console.WriteLine("O valor do ponto 2 é {0}", cponto1.X);
Console.WriteLine("O valor do ponto 2 é {0}", copiaCPonto1.X);
//Atribuição por refêrencia
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 2
};
SPonto copiaPonto1 = ponto1;
ponto1.X = 3; // ATRIBUIÇÃO POR VALOR
Console.WriteLine($"Ponto1 X = {ponto1.X}");
Console.WriteLine($"CopiaPonto1 X = { copiaPonto1.X}");
CPonto ponto2 = new CPonto {
X = 1, Y = 2
};
CPonto copiaPonto2 = ponto2;
ponto1.X = 3; // ATRIBUIÇÃO POR REFERÊNCIA
Console.WriteLine($"Ponto1 X = {ponto2.X}");
Console.WriteLine($"CopiaPonto1 X = { copiaPonto2.X}");
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; // struct: atribuição feita por valor, não por referencia, as alterações em um não serão atribuidas ao outro
ponto1.X = 3; //
Console.WriteLine($"Ponto 1 X:{ponto1.X}");
Console.WriteLine($"Cópia Ponto 1 X:{copiaPonto1.X}");
CPonto ponto2 = new CPonto {
X = 1, Y = 3
};
CPonto copiaPonto2 = ponto2; // classe: atribuição por referencia, as alterações em um serão atribuidas ao outro
ponto1.X = 3;
Console.WriteLine($"Ponto 2 X:{ponto2.X}");
Console.WriteLine($"Cópia Ponto 2 X:{copiaPonto2.X}");
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; //Atribuiçao por VALOR!!!
ponto1.X = 3;
Console.WriteLine($"Ponto 1 X:{ponto1.X}");
Console.WriteLine($"Copia Ponto 1 X:{copiaPonto1.X}");
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2;//Atribuiçao por REFERENCIA!!!
ponto2.X = 4;
Console.WriteLine($"Ponto 2 X:{ponto2.X}");
Console.WriteLine($"Copia Ponto 2 X:{copiaPonto2.X}");
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; // Atribuicao por valor
ponto1.X = 3;
Console.WriteLine($"Ponto 1 X: {ponto1.X}");
Console.WriteLine($"Copia Ponto 1 X: {copiaPonto1.X}");
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; // Atribuicao por referencia
ponto2.X = 4;
Console.WriteLine($"Ponto 1 X: {ponto2.X}");
Console.WriteLine($"Copia Ponto 1 X: {copiaPonto2.X}");
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; //Struct -> Atribuição por valor !!!
ponto1.X = 3;
Console.WriteLine("Ponto1 X:{0}", ponto1.X);
Console.WriteLine("Copia Ponto1 X:{0}", copiaPonto1.X);
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; //Class -> Atribuição por Referencia !!! -> aponta para o mesmo local de memória.
ponto2.X = 4;
Console.WriteLine("Ponto2 X:{0}", ponto2.X);
Console.WriteLine("Copia Ponto2 X:{0}", copiaPonto2.X);
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
//criamos um novo SPonto copia
SPonto copiaPonto1 = ponto1; //Atribuição por VALOR!!! Na STRUCT sempre feito uma atribuição por valor e não por Referência!
ponto1.X = 3; //alteramos o ponto1.X do ponto1;
Console.WriteLine("Ponto 1 X:{0}", ponto1.X);
Console.WriteLine("Copia Ponto 1 X:{0}", copiaPonto1.X);
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; // Atribuição por REFERÊNCIA!!!
ponto2.X = 4;
Console.WriteLine("Ponto 2 X:{0}", ponto2.X);
Console.WriteLine("Copia do Ponto 2 X:{0}", copiaPonto2.X);
}
public static void Executar()
{
SPonto ponto1 = new SPonto()
{
X = 1, Y = 2
};
SPonto conpiaPonto1 = ponto1;
ponto1.X = 10;
CPonto ponto2 = new CPonto()
{
X = 3, Y = 5
};
CPonto copiaPonto2 = ponto2;
ponto2.X = 10;
Console.WriteLine("Struct - Atribuição por valor:");
Console.WriteLine(ponto1.X + " copia " + conpiaPonto1.X);
Console.WriteLine("Class - Atribuição por referência:");
Console.WriteLine(ponto2.X + " copia " + copiaPonto2.X);
}
public static void Executar() // tipo STRUCT é sempre passado por valor e nao por referencia
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto copiaPonto1 = ponto1; // atribuição feita por VALOR!!!
ponto1.X = 3; // atribuição feita por referencia
Console.WriteLine("Ponto 1 x:{0}", ponto1.X); // passado por valor
Console.WriteLine("Copia Ponto 1 x:{0}", copiaPonto1.X); // passado por referencia
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto copiaPonto2 = ponto2; //atribuição feita por referencia,
ponto2.X = 5;
Console.WriteLine("Ponto 2 X:{0}", ponto2.X);
Console.WriteLine("Copia do Ponto 2 X:{0}", copiaPonto2.X);
}
public static void Executar()
{
SPonto ponto1 = new SPonto {
X = 1, Y = 3
};
SPonto CopiaPonto1 = ponto1; //Atribuição por VALOR!
ponto1.X = 3;
Console.WriteLine("Ponto 1 X:{0}", ponto1.X); //Print 3
Console.WriteLine("Copia Ponto 1 X:{0}", CopiaPonto1.X); //Print 1
///////////
CPonto ponto2 = new CPonto {
X = 2, Y = 4
};
CPonto CopiaPonto2 = ponto2; //Atribuição por REFERENCIA!
ponto2.X = 4;
Console.WriteLine("Ponto 1 X:{0}", ponto2.X); //Print 4
Console.WriteLine("Copia Ponto 1 X:{0}", CopiaPonto2.X); //Print 4
}
