Definição de classes

Uma definição de classe é basicamente uma definição de um tipo de dado. Uma classe contém um conjunto de bits representando um estado e um conjunto de operações que permitem modificar o estado. Em geral, as operações são públicas e os dados internos da classe são privados -- as únicas modificações possíveis nos dados são realizadas através das operações que a classe deixa disponível para que o público use.

A informação que permanece escondida do usuário da classe está contida na seção privativa da classe. De fora da classe, é como se aqueles dados não existissem: eles não podem ser acessados ou modificados diretamente.

É possível que dados internos sejam acessados externamente; para tanto, deve-se colocar estes dados na seção pública da classe. (Este foi o mecanismo adotado no exemplo da seção .) A seção pública inicia-se com o rótulo public, seguida pelas declarações (dados ou funções) que poderão ser acessadas externamente.

Funções declaradas dentro de uma classe são chamadas de funções membros, uma vez que elas são membros da classe da mesma forma que os dados declarados na classe. Funções membros são definidas da mesma forma que funções normais -- a única diferença visível é que o nome da função é precedido pelo nome da classe, sendo os nomes separados por ::. O uso do nome da classe como prefixo para o nome da função permite que outras classes usem funções membros com o mesmo nome.

Uma outra diferença existe com relação a funções membros, sendo esta mais significativa: dados privados da classe podem ser acessados por elas, tanto para leitura como para alteração. A implementação de uma função membro de uma classe pode fazer o que quiser com os dados privados da classe, mas nada com os dados privados de outras classes. Este é mais um motivo pelo qual o nome da classe deve preceder o nome da função membro na definição.

Em geral, a parte privativa da classe contém apenas dados, enquanto que a parte pública contém apenas declarações de funções. Entretanto, nada impede que dados sejam declarados também na parte pública e funções na parte privativa.

O exemplo a seguir apresenta, de forma muito simplificada, os conceitos apresentados acima. Neste programa, uma classe contendo um único dado -- o inteiro data_store -- é declarada, e todo acesso ao estado da classe (o valor deste inteiro) é restrito a suas duas funções membro, set e get_value. Estas duas funções são os métodos da classe, na terminologia de orientação a objetos apresentada no Capítulo .

indentation

#include $<$iostream.h$>$

class one_datum {
int data_store;
public:
void set(int in_value);
int get_value(void);
};

void one_datum::set(int in_value)
{
data_store = in_value;
}

int one_datum::get_value(void)
{
return data_store;
}

main()
{
one_datum dog1, dog2, dog3;
int piggy;

dog1.set(12);
dog2.set(17);
dog3.set(-13);
piggy = 123;

// dog1.data_store $=$ 115; This is illegal in C$+$$+$
// dog2.data_store $=$ 211; This is illegal in C$+$$+$

cout $\ll$ "The value of dog1 is " $\ll$ dog1.get_value() $\ll$ begintex2html_wrap_inline$$n";
cout $\ll$ "The value of dog2 is " $\ll$ dog2.get_value() $\ll$ begintex2html_wrap_inline$$n";
cout $\ll$ "The value of dog3 is " $\ll$ dog3.get_value() $\ll$ begintex2html_wrap_inline$$n";
cout $\ll$ "The value of piggy is " $\ll$ piggy $\ll$ begintex2html_wrap_inline$$n";
}

O resultado da execução deste programa é

    The value of dog1 is 12
    The value of dog2 is 17
    The value of dog3 is -13
    The value of piggy is 123

Observe que, dentro da definição da classe, o que está presente na verdade são os protótipos dos métodos. Esta é mais uma razão pela qual protótipos são importantes em C ++.

No início da função main é mostrado como objetos da classe definida são criados -- da mesma forma que variáveis dos tipos padrão da linguagem. O processo de chamar de um dos métodos da classe aplicado a um objeto da classe é conhecido na terminologia de orientação a objetos como enviar uma mensagem. A maneira de se enviar uma mensagem em C ++ é ilustrada neste exemplo. Por exemplo, a linha onde se lê dog1.set(12) pode ser interpretada como ``envie uma mensagem para o objeto dog1 instruindo-o para setar (seu valor interno para) 12.'' Repare como esta forma de acesso assemelha-se sintaticamente ao acesso de dados internos de uma estrutura: o nome do objeto, um ponto (.), e o nome do método.

O exemplo também ilustra, sob a forma de comentários, a ``forma ilegal'' de acesso aos dados internos dos objetos. Caso se tentasse compilar um programa com um comando daquela forma, um erro seria acusado pelo compilador C ++. Observe ainda que não é possível ``misturar'' os dados de dois objetos -- cada objeto tem seus dados exclusivos, e mesmo que eles sejam de uma mesma classe não há como misturá-los.