Exemple #1
0
        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);
        }
Exemple #2
0
        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);
        }
Exemple #3
0
        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);
        }
Exemple #6
0
        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
        }
Exemple #9
0
        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}");
        }
Exemple #10
0
        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}");
        }
Exemple #13
0
        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);
        }
Exemple #14
0
        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);
        }
Exemple #15
0
        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
        }