Classes parciais (C++/CX)

Uma classe parcial é uma construção que suporta cenários nos quais você está modificando uma parte de uma definição de classe, e o software de geração automática de código — por exemplo, o designer XAML — também está modificando o código na mesma classe. Usando uma classe parcial, você pode impedir que o designer substitua seu código. Em um projeto do Visual Studio, o partial modificador é aplicado automaticamente ao arquivo gerado.

Sintaxe

Para definir uma classe parcial, use a partial palavra-chave imediatamente antes da chave de classe do que seria uma definição de classe normal. Uma palavra-chave como partial ref class é uma palavra-chave contextual que contém caracteres de espaço em branco. Definições parciais são suportadas nas construções a seguir.

class ou struct
ref class ou ref struct
value class ou value struct
enum ou enum class
ref interface, interface class, interface structou __interface
union

Este exemplo demonstra um :ref class

partial ref class MyClass {/* ... */};

Conteúdos

Uma definição de classe parcial pode conter qualquer coisa que a definição de classe completa possa conter se a partial palavra-chave tiver sido omitida. Com uma exceção, isso inclui qualquer construção válida, como classes base, membros de dados, funções de membro, enums, declarações de amigo e atributos. E definições embutidas de membros de dados estáticos são permitidas.

A única exceção é a acessibilidade de classe. Por exemplo, a instrução public partial class MyInvalidClass {/* ... */}; é um erro. Quaisquer especificadores de acesso usados em uma definição de classe parcial para MyInvalidClass não afetam a acessibilidade padrão em uma definição de classe parcial ou completa subsequente para MyInvalidClass.

O fragmento de código a seguir demonstra a acessibilidade. Na primeira aula parcial, Method1 é público porque a sua acessibilidade é pública. Na segunda classe parcial, Method2 é privado porque a acessibilidade de classe padrão é privada.

partial ref class N 
{
public:
    int Method1(); // Method1 is public.

};
ref class N 
{   
    void Method2(); // Method2 is private.
};

Declaração

Uma definição parcial de uma classe como MyClass é apenas uma declaração de MyClass. Ou seja, apenas introduz o nome MyClass. MyClass não pode ser usado de uma forma que exija uma definição de classe, por exemplo, saber o tamanho ou MyClass usar uma base ou membro do MyClass. MyClass é considerado definido somente quando o compilador encontra uma definição não parcial de MyClass.

O exemplo a seguir demonstra o comportamento de declaração de uma classe parcial. Após a declaração #1, MyClass pode ser usado como se estivesse escrito como a declaração de encaminhamento, ref class MyClass;. A declaração #2 é equivalente à declaração #1. A declaração #3 é válida porque é uma declaração encaminhada para uma classe. Mas a declaração #4 é inválida porque

MyClass não está totalmente definida.

A Declaração #5 não usa a partial palavra-chave, e a declaração define MyClasstotalmente . Consequentemente, a declaração #6 é válida.

// Declaration #1
partial ref class MyClass {};

// Declaration #2
partial ref class MyClass;

// Declaration #3
MyClass^ pMc; // OK, forward declaration.

// Declaration #4
MyClass mc; // Error, MyClass is not defined.

// Declaration #5
ref class MyClass { };

// Declaration #6
MyClass mc; // OK, now MyClass is defined.

Número e encomenda

Pode haver zero ou mais definições parciais de classe para cada definição completa de uma classe.

Cada definição de classe parcial de uma classe deve preceder lexicamente a definição completa dessa classe, mas não precisa preceder as declarações de encaminhamento da classe. Se não houver uma definição completa da classe, as declarações de classe parciais só poderão ser declarações de encaminhamento.

Todas as chaves de classe, como class e struct devem corresponder. Por exemplo, é um erro codificar partial class X {}; struct X {};.

O exemplo a seguir demonstra número e ordem. A última declaração parcial falha porque a classe já está definida.

ref class MyClass;  // OK
partial ref class MyClass{};  //OK
partial ref class MyClass{}; // OK
partial ref class MyClass{}; // OK
ref class MyClass{}; // OK
partial ref class MyClass{}; // C3971, partial definition cannot appear after full definition.

Definição completa

No ponto da definição completa da classe X, o comportamento é o mesmo como se a definição de X tivesse declarado todas as classes base, membros e assim por diante, na ordem em que foram encontradas e definidas nas classes parciais. Ou seja, os conteúdos das classes parciais são tratados como se tivessem sido escritos no ponto de definição completa da classe, e a pesquisa de nomes e outras regras linguísticas são aplicadas no ponto da definição completa da classe, como se os conteúdos das classes parciais tivessem sido escritos no lugar

Os dois exemplos de código a seguir têm significado e efeito idênticos. O primeiro exemplo usa uma classe parcial e o segundo exemplo não.

ref class Base1 { public: property int m_num; int GetNumBase();};
interface class Base2 { int GetNum(); };
interface class Base3{ int GetNum2();};

partial ref class N : public Base1 
{
public:
    /*...*/

};

partial ref class N : public Base2
{
public:
    virtual int GetNum();
    // OK, as long as OtherClass is
    //declared before the full definition of N
    void Method2( OtherClass^ oc );       
};

ref class OtherClass;

ref class N : public Base3
{    
public:
    virtual int GetNum2();
};

ref class OtherClass;
ref class N : public Base1, public Base2, public Base3 
{
public:    
    virtual int GetNum();
    virtual int GetNum2();
private:    
    void Method2(OtherClass^ oc);

};

Modelos

Uma classe parcial não pode ser um modelo.

Restrições

Uma classe parcial não pode ir além de uma unidade de tradução.

A partial palavra-chave é suportada apenas em combinação com a ref class palavra-chave ou a value class palavra-chave.

Exemplos

O exemplo a seguir define a Address classe em dois arquivos de código. O designer modifica Address.details.h e você modifica Address.ho . Somente a definição de classe no primeiro arquivo usa a partial palavra-chave.

// Address.Details.h
partial ref class Address
{
private:
  Platform::String^ street_;
  Platform::String^ city_;
  Platform::String^ state_;
  Platform::String^ zip_;
  Platform::String^ country_;
  void ValidateAddress(bool normalize = true);
};

// Address.h
#include "Address.details.h"
ref class Address
{
public:
  Address(Platform::String^ street, Platform::String^ city, Platform::String^ state,
    Platform::String^ zip, Platform::String^ country);
  property Platform::String^ Street { Platform::String^ get(); }
  property Platform::String^ City { Platform::String^ get(); }
  property Platform::String^ State { Platform::String^ get(); }
  property Platform::String^ Zip { Platform::String^ get(); }
  property Platform::String^ Country { Platform::String^ get(); }
};

Ver também

Sistema de tipo
Referência da linguagem C++/CX
Referência de namespaces

Feedback

Esta página foi útil?

Last updated on 2025-11-07