Os links foram devidamente cancelados pelo Google por motivo de


continuação direta

• A sintaxe de declaração para atributo de uma classe é:

Atributo:

("MODIFICADOR")* Tipo "ID" Inicializador ? ";"

onde

-MODIFICADOR pode ser uma das seguintes palavras reservadas:

• public, protected ou private, indicando a visibilidade do atributo(a ausência do atributo invisível do pacote onde a classe é declarada;
• inal, indicando que o atributo é uma constante, ou seja, seu valor não pode ser modificado;
• static, indicando que o atributo é um atributo de classe;

-Tipo: NomeDeTipo("[""]")*

NomeDeTipo: Nome | "TIPO_PRIMITIVO"
sendo TIPOPRIMITIVO as palavras reservadas:
boolean, byte, char, double, int, float, long ou short

-Inicializador: define o valor inicial do atributo(obrigatório se o atributo é final). A sintaxe é:

"="(InicializadorSimples | InicializadorDeVetor)
InicializadorSimples:

Expressão

InicializadorDeVetor:

"{" ListaDeExpressões | InicializadorDeVetor)?"}"
ListaDeExpressões:

Expressão (","Expressão)*

ListaDeInicializadorDeVetor: InicializadorDeVetor(","InicializadorDeVetor)*

• A sintaxe de declaração de um método é:

Método:
("MODIFICADOR")* TipoDeRetorno "ID" "("Parametros?")"
(";" | Bloco)

onde

-MODIFICADOR pode ser uma das seguintes palavras reservadas:

• public, protected ou private, indicando a visibilidade do método(a ausência do método invisível do pacote onde a classe é declarada
• final, indicando que o método não pode ser sobrecarregado em classes derivadas. Em Java todos os métodos não estáticos com ecessão dos contrutores são virtuais se a classe foi declarado como final então todos os seus métodos são finais.
• static, indicando que um método é um método de classe
• abstract, incicando que um método é abstrato. Neste caso a classe também tem que ser declarada como abstrato. Um método abstrato não pode ser final ou static. Um método abstrato não tem corpo.

-Tipo de Retorno: Tipo | "VOID"

sendo "VOID" void

-Parâmetros:

Lista de Parâmetros do método, cuja sintaze é:

Parâmetro ( "," Parâmetro)*
Parâmetro: "FINAL"? Tipo
sendo "FINAL" a palavra reservada final, indicando que o parâmetro não pode ter seu valor modificado no corpo do método.

-Bloco: onde bloco é o corpo do método, se este não for abstrato. A sintaxe é:
"{" Sentença* "}"

A sintaxe de sentenças e expressões Java são muito similares a do C++, com poucas diferenças.
A sintaxe de declação de um construtor em Java é:
Construtor:

("MODIFICADOR")* "ID" "("Parâmetros?")"
BlocoDoCtor

onde

-MODIFICADOR

• public, protected ou private, indicando a visibilidade do método(a ausência do método invisível do pacote onde a classe é declarada

-ID é o nome do construtor no qual deve ser idêntico ao nome da classe
-BlocoDoCtor é o corpo do construtor, igual ao corpo de um método. Exceto que a primeira sentença deve ser o Inicializador da super classe se necessário.
"{"
InicializadorDaSuperClasse?
Sentença
"}"
-Inicializador da Super Classe: é um
"SUPER" "(" ListaDeExpressões? ")"";"
sendo "SUPER" a palavra reservada super e ListaDeExpressõe os argumentos para um dos construtores da super classe.

• Uma unidade de compilação Java, pode ter varias declarações de classe, mas obrigatoriamente deverá ter a declaração de uma classe cujo nome é o mesmo nome da unidade de compilação. Esta classe principal deve ser a única classe pública da unidade de compilação
• O ponto de entrada de execução de uma aplicação Java é o método cuja assinatura é: static public void main (string[] args) o qual deve ser declarado na classe principal. O parâmetro args são os argumentos passados para o método principal pela linha de comando.

Exercício: Implemente uma lista de objetos em Java. Com as operações de adicionar, procurar, remover, getters, qtddeElemento, clear, etc. Implemente também um iterador para a lista. Linearmente Encadeada.

Exercício: Estude a interface da classe Object (o site da Sun)
Exercício: Estude a interface da classe Integer

Read more »

Java

Antes de tudo, clique nos links ai do lado, e entre aqui e clique no banner.


Introdução:

• Java é uma linguagem de programação de compilador, uma API(Application Programing Interface) e uma máquina virtual.
• A API Java é uma coleção de pacotes, cada pacote é uma coleção de classes compiladas. A API que acompanha o JDK(Java Development Kit) é bastante grande, o pacote de classes para programação de entrada/saída (inclúi arquivos), estruturas de dados, funções matemáticas, comunicação via rede, interfaces gráficas, acesso a banco de dados, persistência de objetos, programação distribuída, gráficos 2d e 3d, reflexão computacional, web, entre muitas outras. Antes de tentar escrever uma nova classe, procure na API.
• A máquina virtual Java(JVM, Java Virtual Machine) é um programa responsável pela carga de um arquivo Java compilado e pela execução do código objeto desse arquivo.
• Java é dito independente de plataforma e arquitetura porque um "programa" Java é executado por outro programa que é a JVM. Então a independência só ocorre se houver uma JVM disponível para determinada plataforma de arquitetura.
• Java é compilada e interpretada. O compilador Java toma como entrada um programa fonte, codificada em uma arquivo texto, com a extensão ".java" e gera como saída um arquivo com o mesmo nome mas com extensão ".class". Este arquivo contém o código objeto gerado pelo compilador o qual consiste de uma sequência de bytes, cada byte representando uma operação que pode ou não ter outros bytes da sequência como argumentos. Esta sequência de bytes, é chamada de "bytecode". Cada método em uma classe em Java terá o seu bytecode no arquivo ".class". A JVM carrega o arquivo ".class" e interpreta o bytecode.
• Um arquivo ".java" é denominado unidade de compilação. Em uma unidade de compilação podem ser declarados na ordem:

1- Importação de classes(opcional)
2-Tipos dos quais podem ser classes ou interfaces

• Uma declaração de classe em Java obedece a seguinte sintaxe:

DeclaraçãoDeClasse:
("MODIFICADOR")* "class" "ID' ("EXTENDS" Nome) ?
"{"

(Membro)*

"}"

onde
-MODIFICADOR pode ser uma das seguintes palavras reservadas

• public, indicando que a visibilidade da classe é pública, ou seja, pode ser acessada de qualquer outra unidade de compilação(se omitido a visibilidade da classe é restrita a sua unidade de compilação)
• abstract, indicando que a classe é abstrata.
• final, indicando que a classe não pode ser derivada, ou seja, não poe ser superclasse de outra.

-class

-ID, é qualquer modificador em Java.

-EXTENDS, é a palavra reservada "extends", a qual se presente deve ser seguida do nome da superclasse sendo declarada. Em Java apenas herança simples é admitida. Se a superclasse não for especificada a classe sendo declarada deriva implicitamente da classe Object. O nome de uma superclasse pode ser qualificado. Um nome qualificado em Java é definido pela seguinte sintaxe:

Nome:

"ID" ( "." "ID")*

-Membro, pode ser um atributo, um construtor, um método ou uma classe interna. Em Java não há destrutor: todo objeto que não pode ser alcançado pela JVM é automáticamente destruído pelo coletor de lixo da máquina virtual.

• A declaração de uma classe define um novo tipo em relação de tipos primitivos da linguagem.

int (inteiro com sinal de 32 bits)
short (inteiro com sinal de 16 bits)
byte (inteiro com sinal de 8 bits)
long (inteiro com sinal de 64 bits)
float (real de 32 bits)
double (real de 64 bits)
boolean (true ou false)
char (caracter unicode de 2 bytes)

Além destes a palavra reservada void é usada na declaração de métodos que não possuem valor de retorno.

• Além de classes e tipos primitivos, outros tipos podem ser definidos através de vetores uni ou multidimensionais. Por exemplo, o tipo int[] representa o tipo vetor de inteiros e X[][] representa o tipo vetor de vetor de objetos da classe X. Em Java, uma instância de um tipo vetorado é um objeto daquele tipo, ou seja, um vetor em Java é um objeto.
  

Read more »

Cliquem nos links!

Agradeço aos que estão clicando nos links, e pra aumentar ainda mais a arrecadação do saudoso Google, e cliquem aqui para cair em outro blog meu e clicar no banner!

Mais uma vez agradeço!

Read more »

Programinhas em Java

public class MeuNome
{

public static void main( String[] args)
{

for(int i=0; i < args.length; i++)
System.out.println(args[i]);

}

}

public class MeuNome
{

public static void main( String[] args)
{

String nome="";
int length=args.length;
if(length>0)
{

nome=args[0];
for(int i=1; i < length; i++)

nome=nome+' '+args[1];

}
System.out.println(nome);

}

}

Read more »

Erros no site!

Se puderam notar, quando no código do site tiver coisas entre "<>" o html está eliminando oque tem dentro, logo, em alguns lugares fica por exemplo: template<>, mas deveria ter um Banana entre os "<>". E eu não sei como arrumar. Se alguém souber, de uma ajudinha!
E não esqueçam de clicar nos links ai do lado!
[]'s

Read more »

Cliquem nos links de anúncio!

Quem puder clicar nos links de anúncio Google ai do lado. Fico grato!

[]'s

Read more »

Não somente, estrutura de dados diversas não somente podem ser implementadas em templates em C++, mas também iteradores de estruturas de dados. ..... responsável por "atravessar" um contêiner em uma determinada ordem e para cada elemento visitado de um contêiner disponibilizado para algum tipo de processamento. A ordem de atravessamento depende do tipo de contêiner. Em uma lista por exemplo pode ser do início para o fim ou vice-versa; em uma árvore pode ser em pré-ordem, pós ordem. Há iterators que em adição permitem remoção e adição de elementos no contêiner. No exemplo a seguir é de um template que implementa um iterador de lista linearmente encadeadas, ....., a ordem dos links, ou seja, da cabeça para a cauda. Um iterador sempre possui métodos que informam se ainda há elementos do contêiner a serem visitados e em caso verdadeiro qual é o próximo elemento a ser visitado. Estas operações são definidas no template pelos métodos HasNext e Next

template<>
class ListIteratorImp
{

private:

ListImp<>& List;
T* Cur;

public:

ListIteratorImp( ListImp<>& List): List( List), Cur(Cist.PeekHead())
{}
bool HasNext() const
{

return Cur!= "NULL";

}
T* Next()
{

T* temp= Cur;

if(Cur)

Cur= Cur->Next;

return temp;

}
void Restart()
{

Cur= List.PeekHead();

}

};

Em C++, templates podem também ser moldes de funções como no exemplo a seguir:

template <>
void Print(ListImp<>& List)
{

for(ListIteratorImp<> Lit(List); Lit.HasNext();)

Print(Lit.Next());

}

O template acima é um gerador de funções sendo que, cada função gerada tomo como argumento uma referência para um lista de objetos do tipo T, parâmetro do template, e que usando um iterador atravessa a lista em invoca um método Print responsável por imprimir objetos do tipo T. Note o uso das funções HasNext e Next. Observe também que ao ser gerada a função para um tipo T, uma função Print que toma como argumento um ponteiro para o tipo T deve ter sido anteriormente. O compilador gera uma função a partir de um template quando esta for chamada em alguma expressão e não existir nenhuma função com o mesmo nome, número e tipo de parâmetros definidos manualmente. O exemplo abaixo ilustra:

void Print(Banana*);
ListImp<> bananas;
void main()
{

bananas.Add(new Banana(...));
...
Iterate(bananas, Print);

}

Podemos definir em uma função mais genérica para processamento de uma lista a qual toma como argumento um ponteiro para uma função a ser chamada para cada elemento visitado por um iterador, assim ao invés de ter uma função para imprimir, outra para salvar em arquivo, etc, teremos apenas uma função que toma como argumento a operação a ser realizada, isto opde ser implementado pelo seguinte template:

template<>
void Iterate(ListImp<>& List, void (*func)(T*))
{

for(ListIteratorImp<>& Lit(List); Lit.HasNext();)

(*func)(Lit.Next());

}

O trecho de código a seguir ilustra o uso do template:...Uma alternativa aos métodos HasNext da classe paramétrica ListIteratorImpm, consiste em sobrecarregar os operadores de conversão para inteiro e de pré e pós incremento. Desta forma um objeto do tipo ListIteratorImp<> pode ser implicitamente convertido para inteiro em expressões de testes em sentenças de iteração, for, do e while, dispensando assim o uso de HasNext. Similarmente o próximo elementoa a ser visitado pelo iterador pode ser obtido pelos operadores de incremento, dispensando o uso de Next, a idéia é tornar o código mais parecido com o de laços envolvendo números e portanto mais legível.(note no template ListIteratorImp a sintaxe para distinguir a sobrecarga do operador de pré do de pós incremento.)Com esses operadores sobrecarregados, o template da função iterate pode agora ser escrito como:

template <>
void Print(ListImp<>& List)
{

for(ListIteratorImp<> Lit(List); Lit(); ++Lit)

Print(Lit.Current());

}

operator int()
{

return Cur!='NULL';

}

T* operator ++(int)
{

return Next();

}

T* operator ++()
{

if(Cur)

Cur=Cur->Next;

return Cur;

}
RTTI significa Informações de Tipo em Tempo de Execução, em C++ um tipo é representado por uma estrutura do tipo "typeinfo" a qual é declarada no arquivo de cabeçalho #include <>, em tempo de execução o tipo de uma expressão, e o nome do tipo como o operador typeid. A sintaxe é

typeid(expressão)
typeid(nome de tipo)

O operador typeid retorna o typeinfo como argumento. O método mais útil de typeinfo é name, no qual retorna um ponteiro para .......Ascz.......... contendo um nome do tipo. Por exemplo:

#include <>
#include <> class Banana{....};
int main()
{

printf(typeid(Banana).name());

}

void PrintName(Primitivo2i)* p)
{

cout<< p="=">}

Observação: para contornar um bug do GCC podemos escrever

#include<>
void PrintName(const type_info& info)
{

const char* name= info.name();
while(isdigit(*name))

name++;

cout <<>

}

void PrintName(Primitvo2D* p)
{

if( p==0)

cout << "null";

else

PrintName(typeid(*p));

}

Outro método útil da classe Type_info é o operador de comparação ==.

Os novos operadores de cast, aquele que é relaciona com a DinamicCast o qual tenta converter em tempo de execução a expressão passada como argumento para o tipo entre < >. Se a conversão puder ser feita DinamicCast retorna um ponteiro não nulo. Caso contrário o argumento não pode ser convertido para o tipo especificado. O trecho de código a seguir ilustra:

Primitivo2D* p;
Line2D* l;,br>...
l=dynamic_cast<> (p);
if(l!=0)

ProcessaLinha2D(l);

DinamicCast é a forma segura e que sempre funciona de fazer:

if(typeid(*p)==typeid(Line2D))

l=(Line2D*)p;

nem sempre permitido pelo compilador.

Read more »

Exercício de Programação 3

Implementar uma AVL de elementos de qualquer tipo para o qual os operadores < e == sejam aplicáveis, além do construtor e do operador de cópia. Sua AVL deve implementar pelo menos métodos para:
Adição, remoção, verificação se um elemento contém ou não(booleana), método iteração em pré-ordem, in-ordem e pós-ordem, além disso implemente um iterador para sua AVL o qual deve ser capaz de, a exemplo do que faz o método de iteração, atravessar a coleção em pré-ordem, in-ordem e pós-ordem.

Entregar: 13 de outubro.
Fonte, executável totalmente funcionando e relatório explicando atributo por atributo, método por método. Em Latex de preferência, entregar só o pdf.

Read more »

Aula 12

template<>
class ListIteratorImp
{

private:

ListImp<>& List;
T* Cur;

public:

ListIteratorImp( ListImp<>& List): List( List), Cur(Cist.PeekHead())
{}
bool HasNext() const
{

return Cur!= "NULL";

}
T* Next()
{

T* temp= Cur;

if(Cur)

Cur= Cur->Next;

return temp;

}
void Restart()
{

Cur= List.PeekHead();

}

};

template <>
void Print(ListImp<>& List)
{

for(ListIteratorImp<> Lit(List); Lit.HasNext();)

Print(Lit.Next());

}

template<>
void Iterate(ListImp<>& List, void (*func)(T*))
{

for(ListIteratorImp<>& Lit(List); Lit.HasNext();)

(*func)(Lit.Next());

}

void Print(Banana*);
ListImp<> bananas;
void main()
{

bananas.Add(new Banana(...));
...
Iterate(bananas, Print);

}

//Esta classe esta alterada, na parte for

template <>
void Print(ListImp<>& List)
{

for(ListIteratorImp<> Lit(List); Lit(); ++Lit)

Print(Lit.Current());

}

operator int()
{

return Cur!='NULL';

}

T* operator ++(int)
{

return Next();

}

T* operator ++()
{

if(Cur)

Cur=Cur->Next;

return Cur;

}

Read more »

Publicidade

Se alguém notou, há um espaço de Anúncios Google ai do lado! Sempre que entrarem aqui, dê um clique em algum dos anúncios, espere alguns segundos e pronto, estará me ajudando!
Fico grato!

Read more »

Aula 11

C++ implementa templates os quais podem ser usados em classes e
funções. Para exemplificar seu uso em classes, sejam as classes
abaixo, as quais representam um elemento de uma lista linearmente
encadeada e a lista propriamente dita:

Ex.
struct Banana
{
float L;
float D;
Banana *Next;
} 
class ListBanana
{
public:
 
ListBanana();
~ListBanana();
void Add(Banana*);
void Remove(Banana*);
int GetNumberOfElements() const;
bool IsEmpty() const;
void Clear();
Banana *PeekHead() const;
    
private: 

Banana *Head;
Banana *Tail;
int NumberOfElements;
ListBanana(const ListBanana&); // Não pode acessar
//os métodos private, logo não há construtor de cópia
ListBanana& operator=(const ListBanana&);
};

void ListBanana :: Clear()
{

while(Head)
{

Banana *temp = Head;
Head = Head -> next;
delete temp;
}
Tail = NumberOfElements = 0;
}

OBS:
Banana b; // Cria objeto

List lb // Cria classe
// classe (instância do template); objeto (instância da classe);

typedef List ListBanana;
ListBanana lb;

Vamos supor agora que se queira implementar uma lista de um
outro tipo qualquer, por exemplo: "Laranja". Sem templates há
duas alternativas:

1. 1. Replicar a implementação da lista trocando "Banana" por "Laranja". Isto é incoveniente por razões óbvias, dentre as quais, há necessidade de alterações manuais no código replicado, sempre que um novo método seja adicionado a classe ou que algum método já existente seja alterado.
2. 2. Para evitar a replicação, os elementos de uma lista seriam de classes todas elas derivadas de uma classe chamada:

class ListElement
{
private:
ListElement *Next;
friend class List;
};

Assim, "Banana" e "Laranja" derivariam de "ListElement" e haveria
apenas uma implementeção da classe "List", cujos elementos seria
do tipo "ListElement". O incoveniente é que um objeto do tipo
"List" seria um contêiner de quaisquer objeto do tipo "ListElement",
ou seja, poderíamos ter na mesma lista "Bananas" e "Laranjas".
As vezes é justamente isso que se quer, mas nem sempre.
Quando for este o caso, podemos usar templates.

Uma lista genérica pode ser definida em C++ através do seguinte template:

template 
class ListImp
{
public:

ListImp();
~ListImp();
void Add(T*);
void Remove(T*);
int GetNumberOfElements() const;
bool IsEmpty() const;
void Clear();
T *PeekHead() const;
void AddAtHead(T*);

private:
T *Head;
T *Tail;
int NumberOfElements;
ListImp(const ListImp&);
ListImp& operator=(const ListImp&);

}

template 
void ListImp :: Clear()
{
while(Head)
{
T *temp = Head;
Head = Head -> next;
delete temp; 
}
Tail = NumberOfElements = 0;
}

No exemplo acima, "" é o parâmetro do template, o qual representa
um tipo qualquer chamado "T". Note que no corpo da classe, "T"
é usado para representar o tipo de atributos, valores de retorno de
método e parâmetros de método. Um template pode ter qualquer
número positivo de parâmetros.
Um template de uma classe não é uma classe, mas um molde a
partir do qual o compilador gera uma classe. Gerar uma classe a
partir de um template, significa instanciar o template. Para tal,
basta escrever o nome da classe e fornecer um argumento:

... ListImp ...

Supoe-se que o template seja instanciado somente uma vez pelo compilador. Quando um template é instanciado todo o código definido no molde é gerado trocando-se o parâmetro pelo argumento(no exemplo todo T é trocado por Banana). Veja a analogia:

ListImp <> | B;

Na declaração acima ocorre a criação da classe que representa uma lista de Bananas, se esta ainda não tiver sido criada pelo compilador(instanciação do template) e em seguida a criação de um objeto chamado LB do tipo List da Banana(instanciação da classe).

Instanciação de template é igual a classe e instanciação de classe é igual a objeto

Cada instanciação de um template com diferentes argumentos replica todo o código definido no molde. Isto é oque faríamos manualmente no item 1 listado anteriormente; A vantagem é que a tarefa é executada automaticamente pelo compilador. Mas tenha em mente que a replicação ocorre. Portanto embora seja uma solução interessante em muitos casos templates devem ser usados criteriosamente. No caso de lista os métodos são simples e sua replicação não aumentaria demais o tamanho do programa objeto. Isto não ocorre com tudo, em estruturas que requerem um código mais complexo, como por exemplo AVLs. Nesse caso poderíamos criar uma classe base e implementaria os métodos mais complicados e que operariam sobre um tipo genérico como feito a seguir:

class AVLNode
{

public:

AVLNode* Righ;
AVLNode* Left;
int Balance;

};

class AVLBase
{
private:

AVLNode* Root;
int NumberOfElements;

protected:

void Add(AVLNode* );
...

};

A classe AVLBase implementa as operações de inserção, remoção, e atravessamento de uma AVL considerando que os elementos são do tipo AVLNode. Esses métodos são declarados protegidos em AVLBase.

template <>
class AVLElement: public AVLNode
{
public:

T Value;
...

};

template <>
class AVL: public AVLBase
{
public:

void Add(const TB Value)
{

AVLBase::Add(new AVLElement <> (Value));

}

...

};

O template AVLElement gera classes cujos objetos são nós tipo AVL com valor do tipo T. O template AVL gera classes cujos objetos são AVLs de elementos do tipo T. Note que agora a instanciação desse template não replica o código complicado da estrutura de dados AVL o qual foi implementado em AVLBase.

No template ListImp o tipo T deve ser uma classe que declara como atributo público Next. Esta exigência impede que usemos o ListImp para gerar uma lista de Inteiros por exemplo. Isto pode ser contornado com os seguintes templates:

Template
class List
{

public:

List();

~List();
void Add(T*);

void AddAtHead(T*);
void Remove(T*);
int GetNumerOfElements() const;
bool IsEmpty() const;
void Clear();
T* PeekHead() const;

private:

T* Tail;

T* Head;
int NumberOfElements;
List(const List<>&);
List operator=(const List<>&);

}

O template List gera classes cujos objetos são listas de elementos cujo valor são do tipo T. Supoe-se agora que sobre o tipo T sejam definidas as operações de cópia e comparação(verifique).

Read more »

Aula 10 - Templates e RTTI em C++

Aula 01 atualizada com a parte de "Construtor de Cópia".

=]

Templates e RTTI em C++

struct Banana
{

float L;
float D;
Banana* Next;

};
class ListBanana
{

public:

ListBanana();
Add(Banana*);
Remove(Banana*);
int GetNumerOfElements() const;
bool IsEmpty() const;
void Clear();
Banana* PeekHead() const;

private:

Banana* Head;
Banana* Tail;
int NumberOfElements;
ListBanana(const ListBanana&);
ListBanana operator=(const ListBanana&);

}

void
ListBanana::Clear()
{

while(Head)
{

Banana* temp=Head;
Head=Head->Next;
delete temp;

}
int=0;
NumberOfElements
}

Template
class List
{

public:

List();

~List();
void Add(T*);

void AddAtHead(T*);
void Remove(T*);
int GetNumerOfElements() const;
bool IsEmpty() const;
void Clear();
T* PeekHead() const;

private:

T* Tail;

T* Head;
int NumberOfElements;
List(const List< t >&);
List operator=(const List< t >&);

}

Template

void
List< t >::Clear()
{

while(Head)
{

T* tempo=Head;
Head=Head->Next;
delete temp;

}

}

List< banana > |B;
classe...............objeto
(instância do ....(instância da
template)............classe)


Template
class ListImp
{

public:

ListImp();

~ListImp();
void Add(T*);

void AddAtHead(T*);
void Remove(T*);
int GetNumerOfElements() const;
bool IsEmpty() const;
void Clear();
T* PeekHead() const;

private:

T* Tail;

T* Head;
int NumberOfElements;
ListImp(const ListImp&);
ListImp& operator=(const ListImp&);

}

Template
struct ListElement
{
T Value;
ListElement< t >*Next;
ListElement(const T& value):Value(value)
{}
}


Template
class List
{
public:
void Add(const T&);
void AddAtHead(const T&);
bool Remove(const T&);
bool Contains(const T&) const;
bool IsEmpty() const;
void Clear()
void GetNumberOfElements() const;
private:
ListImp< listelement< t >> Imp;
List(const List< t >&);
List& operator= (const List< t > b);

Exercício, implemente os métodos!
};

Read more »