Instanciação de objetosObject instantiation

Tipos de referência (ref) só podem ser instanciados no heap gerenciado, não na pilha ou no heap nativo.Reference (ref) types can only be instantiated on the managed heap, not on the stack or on the native heap.Tipos de valor podem ser instanciados em pilha ou o heap gerenciado.Value types can be instantiated on the stack or the managed heap.

Visibilidade de tipoType visibility

Você pode controlar a visibilidade dos tipos common language runtime (CLR) para que, se um assembly for referenciado, os tipos no assembly possam ser visível ou não é visível fora do assembly.You can control the visibility of common language runtime (CLR) types so that, if an assembly is referenced, types in the assembly can be visible or not visible outside the assembly.

Visibilidade de membroMember visibility

Você pode fazer acesso a um membro de uma classe pública de dentro do mesmo assembly diferente de acesso a ele de fora do assembly usando pares de especificadores de acesso public, protected, e privateYou can make access to a member of a public class from within the same assembly different than access to it from outside the assembly by using pairs of the access specifiers public, protected, and private

O exemplo a seguir mostra um tipo público que tem membros que são declarados com a acessibilidade diferente e, em seguida, mostra o acesso a esses membros de dentro do assembly.The following sample shows a public type that has members that are declared with the different accessibilities, and then shows the accessing of those members from inside the assembly.

in Public_Function
in Protected_Public_Function
in Public_Protected_Function
in Internal_Function
=======================
in function of derived class
in Protected_Function
in Protected_Private_Function
in Private_Protected_Function
exiting function of derived class
=======================

O exemplo a seguir consome o componente que é criado no exemplo anterior e, portanto, mostra como acessar os membros de fora do assembly.The following sample consumes the component that's created in the previous sample, and thereby shows how to access the members from outside the assembly.

in Public_Function
=======================
in function of derived class
in Protected_Function
in Protected_Public_Function
in Public_Protected_Function
exiting function of derived class
=======================

Defina um construtor estático como uma função de membro privado, como ele se destina a ser chamado somente pelo CLR.Define a static constructor as a private member function, because it is meant to be called only by the CLR.

Semântica do ponteiroSemantics of the this pointer

Quando você estiver usando o Visual C++ para definir tipos, o this ponteiro em um tipo de referência é do tipo "identificador".When you are using Visual C++ to define types, the this pointer in a reference type is of type "handle".O this ponteiro em um tipo de valor é do tipo "ponteiro interior".The this pointer in a value type is of type "interior pointer".

Essas semânticas diferentes da this ponteiro pode causar um comportamento inesperado quando um indexador padrão é chamado.These different semantics of the this pointer can cause unexpected behavior when a default indexer is called.O exemplo a seguir mostra a maneira correta de acessar um indexador padrão em um tipo de ref e um tipo de valor.The next example shows the correct way to access a default indexer in both a ref type and a value type.

Funções ocultar por assinaturaHide-by-signature functions

No C++ padrão, uma função em uma classe base permanece oculto por uma função que tem o mesmo nome em uma classe derivada, mesmo se a função de classe derivada não tem o mesmo número ou tipo de parâmetros.In standard C++, a function in a base class is hidden by a function that has the same name in a derived class, even if the derived-class function does not have the same number or kind of parameters.Isso é conhecido como ocultar por nome semântica.This is referred to as hide-by-name semantics.Um tipo de referência, uma função em uma classe base pode apenas estar ocultos por uma função em uma classe derivada se o nome e a lista de parâmetros são os mesmos.In a reference type, a function in a base class can only be hidden by a function in a derived class if both the name and the parameter list are the same.Isso é conhecido como ocultar por assinatura semântica.This is known as hide-by-signature semantics.

Semântica de ocultar por assinatura, quando uma função é chamada em um objeto, o compilador identifica a classe mais derivada que contém uma função que atendem a chamada de função.Under hide-by-signature semantics, when a function is called on an object, the compiler identifies the most derived class that contains a function that could satisfy the function call.Se houver apenas uma função na classe que pode satisfazer a chamada, o compilador chama essa função.If there is only one function in the class that could satisfy the call, the compiler calls that function.Se houver mais de uma função na classe que pode satisfazer a chamada, o compilador usa regras de resolução para determinar qual função a ser chamada de sobrecarga.If there is more than one function in the class that could satisfy the call, the compiler uses overload resolution rules to determine which function to call.Para obter mais informações sobre regras de sobrecarga, consulte sobrecarregamento de função.For more information about overload rules, see Function Overloading.

Porque o valor de retorno não é considerado parte da assinatura de uma função, uma função de classe base fica oculto se ele tem o mesmo nome e utiliza o mesmo número e tipo de argumentos como uma função de classe derivada, mesmo que ele difere no tipo do valor de retorno.Because the return value is not considered part of a function's signature, a base-class function is hidden if it has the same name and takes the same number and kind of arguments as a derived-class function, even if it differs in the type of the return value.

O exemplo a seguir mostra o que é possível ocultar uma função, mesmo se a classe base tem a mesma assinatura que a classe derivada.The following sample shows that it's possible to hide a function even if the base class has the same signature as the derived class.

Construtores de cópiaCopy constructors

O padrão C++ informa que um construtor de cópia é chamado quando um objeto for movido, de modo que um objeto é criado e destruído no mesmo endereço.The C++ standard says that a copy constructor is called when an object is moved, such that an object is created and destroyed at the same address.

No entanto, quando /clr é usado para compilação e uma função que é compilada para uma nativa de função em que uma classe nativa de chamadas MSIL — ou mais de um — é passado por valor e onde a classe nativa tem um construtor de cópia e/ou destrutor, nenhuma cópia construtor é chamado e o objeto é destruído em um endereço diferente onde ele foi criado.However, when /clr is used to compile and a function that's compiled to MSIL calls a native function where a native class—or more than one—is passed by value and where the native class has a copy constructor and/or destructor, no copy constructor is called and the object is destroyed at a different address than where it was created.Isso pode causar problemas se a classe tiver um ponteiro em si mesmo, ou se o código é objetos de acompanhamento por endereço.This could cause problems if the class has a pointer into itself, or if the code is tracking objects by address.

A presença de um destruidor não implica a presença de um finalizador.The presence of a destructor does not imply the presence of a finalizer.No entanto, a presença de um finalizador implica que você deve definir um destruidor e chamar o finalizador desse destruidor.However, the presence of a finalizer implies that you must define a destructor and call the finalizer from that destructor.Isso fornece para a liberação determinística dos recursos não gerenciados.This provides for the deterministic release of unmanaged resources.

Suprime a chamar o destruidor — usando SuppressFinalize— finalização do objeto.Calling the destructor suppresses—by using SuppressFinalize—finalization of the object.Se o destruidor não é chamado, o finalizador do seu tipo eventualmente será chamado pelo coletor de lixo.If the destructor is not called, your type's finalizer will eventually be called by the garbage collector.