# overloading

capacidades de overloading ("sobrecarga") de exibições, funções e operadores

## Descrição

No Scilab, exibições, funções e operadores de variáveis podem ser definidos para novos objetos utilizando funções (codificadas no Scilab ou primitivas).

Exibição (Display)

  a exibição de objetos definidos por uma estrutura `tlist` pode ser sobrecarregada (a exibição padrão é semelhante a de `list`'s). A função de sobrecarga não deve ter argumentos de saída e deve ter um único argumento de entrada. Seu nome é formado como segue: `%<tlist_type>_p` onde `%<tlist_type>` significa a primeira entrada do componente do tipo `tlist` truncado aos 9 primeiros caracteres.

Operadores (Operators)

  cada operador que não está definido para dados tipos de operandos pode ser definido. A função de sobrecarga deve ter um único argumento de saída e um ou dois de entrada de acordo com o número de operandos. O nome da função é definido como segue:

para operadores binários: `%<tipo_do_primeiro_operando>_<código_do_ operador>_<tipo_do_segundo_operando>`

para operadores unários: `%<tipo_do_operando>_<código_do_operador>`

Operadores de extração e inserção que são n-nários são descritos abaixo.

`<tipo_do_operando>`, `<tipo_do_primeiro_operando>`, `<tipo_do_segundo_operando>` são seqüências de caracteres associadas a cada tipo de dado como descrito na tabela seguinte:

tipo de dado | código "char" | tipo de dado | código "char"
constante | `s` | booleano | `b`
string | `c` | bibilioteca | `f`
ponteiro de função | `fptr` | manipulador | `h`
inteiro | `i` | lista | `l`
função | `m` | função compilada | `mc`
polinômio | `p` | esparso | `sp`
esparso booleano | `spb` | tlist | `tlist_type`
polinômio de tamanho implícito | `ip` | matriz esparsa do Matlab | `msp`
mlist | `mlist_type` | ponteiro | `ptr`

`<código_do_operador>` é um único caractere associado a cada operador como descrito na tabela seguinte:

`op` | char code
`'` | t
`+` | a
`-` | s
`*` | m
`/` | r
`\` | l
`^` | p
`.*` | x
`./` | d
`.\` | q
`.*.` | k
`./.` | y
`.\.` | z
`:` | b
`*.` | u
`/.` | v
`\.` | w
`[a,b]` | c
`[a;b]` | f
`() extraction` | e
`() insertion` | i
`==` | o
`<>` | n
`|` | g
`&` | h
`.^` | j
`.'` | 0
`<` | 1
`>` | 2
`<=` | 3
`>=` | 4
`~` | 5
`iext` | 6

A função de sobrecarga para sintaxe de extração `b=a(i1,...,in)` tem a seguinte seqüência de chamamento: `b=%<tipo_de_a>_e_(i1,...,in,a)`

e a sintaxe`[x1,..,xm]=a(i1,...,in)` tem a seguinte seqüência de chamamento: `[x1,..,xm]=%<tipo_de_a>_e_(i1,...,in,a)`

A função de sobrecarga associada à sintaxe de inserção `a(i1,...,in)=b` tem a segunite seqüência de chamamento:`a=%<tipo_de_b>_i_<tipo_de_a>(i1,...,in,b,a)` .

O código "char" `6` pode ser usado para alguns algoritmos de inserção complexos como `x.b(2)=33` onde o campo `b` não está definido na estrutura `x`. A inserção é automaticamente decomposta em `temp=x.b;` `temp(2)=33;` `x.b=temp`. O código "char" `6` é usado para o primeiro passo desse algoritmo. A função de sobrecarga de `6` é muito semelhante à função de `e`'s.

Funções (Functions)

  algumas funções primitivas básicas também podem ser sobrecarregadas para novos tipo de dados. Quando tal função não é definida para tipos de dados particulares, a função `%<tipo_de_um_argumento>_<nome_da_função>` é chamada. O usuário pode adicionar a esta função chamada a definição associada aos tipos de dados de entrada.

## Exemplos

    //EXIBIÇÃO
                function [] = %tab_p(l)
                disp([[' '; l(3)] [l(2); string(l(4))]])
                endfunction

                tlist('tab', ['a', 'b'], ['x'; 'y'], rand(2, 2))

    //OPERADOR
                function x = %c_a_s(a, b)
                x = a + string(b);
                endfunction

                's' + 1

    //FUNÇÃO
                function x = %c_sin(a)
                x = 'sin(' + a + ')'
                endfunction

                sin('2 * x')

## Ver Também

- tlist
- disp
- symbols