Estou mudando o template do site!

Como podem notar, o template esta sendo trocado! Caso não tenha gostado, guarde tudo oque você acha contigo! =]
Ainda não terminei de arrumar, isso dá um trabalho danado!

Abraços!

Read more »

Vou colocar as aulas no site do CACOM também!

Vou começar a colocar as aulas de prog3 no site do CACOM, com o intuito de divulgação do site! Por enquanto será aqui e lá. Coloquei apenas a primeira aula!

Pra quem quiser dar uma olhada, Site CACOM
Entre em Recursos, depois em Prog3.

[]'s

Read more »

Aula 8 e Aula 9

Seguinte, faltei a última aula, e a aula de hj eu vou colocar oque ele passou na última aula!






#if !defined(__Exception_h)
#define __Exception_h

//[]------------------------------------------------------------------------[]
//| |
//| Object Structural WorkBench Class Library |
//| Version 2.0 |
//| |
//| Copyright® 1999-2004, Paulo Aristarco Pagliosa |
//| All Rights Reserved. |
//| |
//[]------------------------------------------------------------------------[]
//
// OVERVIEW: Exception.h
// ========
// Class definition for generic exception.

#if !defined(__lstring_h)
#include "lstring.h"
#endif


//////////////////////////////////////////////////////////
//
// Exception: generic exception class
// =========
class Exception
{
public:
// Constructors
Exception();
Exception(const Exception&);
Exception(const String&);

String GetMessage() const;
operator const CHAR_T*() const;

protected:
String Message;

private:
Exception& operator =(const Exception&);

}; // Exception


//////////////////////////////////////////////////////////
//
// OutOfRangeException: out of range exception class
// ===================
class OutOfRangeException: public Exception
{
public:
OutOfRangeException();
OutOfRangeException(const String&);

}; // OutOfRangeException


//////////////////////////////////////////////////////////
//
// IndexOutOfBoundsException: index out of bounds exception class
// =========================
class IndexOutOfBoundsException: public Exception
{
public:
IndexOutOfBoundsException();
IndexOutOfBoundsException(const String&);

}; // IndexOutOfBoundsException


//////////////////////////////////////////////////////////
//
// ClassNotFoundException: class not found exception
// ======================
class ClassNotFoundException: public Exception
{
public:
// Constructor
ClassNotFoundException(const String&);

}; // ClassNotFoundException


//////////////////////////////////////////////////////////
//
// IOException: IO exception
// ===========
class IOException: public Exception
{
public:
// Constructors
IOException();
IOException(const String&);

}; // IOException


//////////////////////////////////////////////////////////
//
// Exception inline implementation
// =========
inline
Exception::Exception()
{}

inline
Exception::Exception(const Exception& e):
Message(e.Message)
{}

inline
Exception::Exception(const String& message):
Message(message)
{}

inline String
Exception::GetMessage() const
{
return Message;
}

inline
Exception::operator const CHAR_T*() const
{
return (const CHAR_T*)Message;
}


//////////////////////////////////////////////////////////
//
// OutOfRangeException inline implementation
// ===================
inline
OutOfRangeException::OutOfRangeException():
Exception(STRING_C("Out of range exception"))
{}

inline
OutOfRangeException::OutOfRangeException(const String& message):
Exception(message)
{}


//////////////////////////////////////////////////////////
//
// IndexOutOfBoundsException inline implementation
// =========================
inline
IndexOutOfBoundsException::IndexOutOfBoundsException():
Exception(STRING_C("Index out of bounds exception"))
{}

inline
IndexOutOfBoundsException::IndexOutOfBoundsException(const String& message):
Exception(message)
{}


//////////////////////////////////////////////////////////
//
// ClassNotFoundException inline implementation
// ======================
inline
ClassNotFoundException::ClassNotFoundException(const String& className)
{
Message = String(STRING_C("Class not found exception: ")) + className;
}


//////////////////////////////////////////////////////////
//
// IOException inline implementation
// ===========
inline
IOException::IOException()
{
Message = STRING_C("IO exception");
}

inline
IOException::IOException(const String& message):
Exception(message)
{}


#endif







//[]------------------------------------------------------------------------[]
//| |
//| Object Structural WorkBench Class Library |
//| Version 2.0 |
//| |
//| Copyright® 1999-2004, Paulo Aristarco Pagliosa |
//| All Rights Reserved. |
//| |
//[]------------------------------------------------------------------------[]
//
// OVERVIEW: lstring.cpp
// ========
// Class definition for string.

#if !defined(__Exception_h)
#include "Exception.h"
#endif

#define MIN_STRBUF_SIZE 4

//
// Roundup string body size
//
inline int
RoundupSize(size_t size)
{
return (size + MIN_STRBUF_SIZE - 1) & -MIN_STRBUF_SIZE;
}


//////////////////////////////////////////////////////////
//
// StringBody implementation
// ==========
StringBody* StringBody::EmptyString = StringBody::New(STRING_C(""));

void*
StringBody::operator new(size_t size, size_t length)
{
return ::operator new(RoundupSize(size + (length + 1) * sizeof(CHAR_T)));
}

StringBody*
StringBody::New(const CHAR_T* s)
{
return s == 0 ? New() : New(s, STRLEN(s));
}

StringBody*
StringBody::New(const CHAR_T* buffer, int length)
{
StringBody* body = New(length);

STRNCPY(body->StringBuffer(), buffer, length);
body->StringBuffer()[length] = 0;
return body;
}

StringBody*
StringBody::Append(StringBody* s)
{
if (s->IsEmpty())
return this->MakeUse();
if (this->IsEmpty())
return s->MakeUse();

StringBody* body = New(this->StringBuffer(), this->Length + s->Length);

STRCPY(body->StringBuffer() + this->Length, s->StringBuffer());
return body;
}

int
StringBody::Compare(StringBody* s)
{
return this == s ? 0 : STRCMP(StringBuffer(), s->StringBuffer());
}

const CHAR_T&
StringBody::operator [](int i)
{
if (i <>= Length)
throw OutOfRangeException();
return StringBuffer()[i];
}

int
StringBody::IndexOf(CHAR_T c) const
{
const CHAR_T* stringBuffer = (const CHAR_T*)(*this);
const CHAR_T* indexPointer = STRCHR(stringBuffer, c);

return indexPointer ? indexPointer - stringBuffer : - 1;
}

int
StringBody::LastIndexOf(CHAR_T c) const
{
const CHAR_T* stringBuffer = (const CHAR_T*)(*this);
const CHAR_T* indexPointer = STRRCHR(stringBuffer, c);

return indexPointer ? indexPointer - stringBuffer : - 1;
}

StringBody*
StringBody::Reverse()
{
if (this->IsEmpty())
return New();

CHAR_T* thisBuffer = StringBuffer();
StringBody* body = New(Length);
CHAR_T* bodyBuffer = body->StringBuffer();

for (int n = Length; n;)
*bodyBuffer++ = thisBuffer[--n];
*bodyBuffer = 0;
return body;
}

StringBody*
StringBody::ToLower()
{
if (this->IsEmpty())
return New();

CHAR_T* thisBuffer = StringBuffer();
StringBody* body = New(Length);
CHAR_T* bodyBuffer = body->StringBuffer();

for (int i = 0; i < Length; ++i)
bodyBuffer[i] = (CHAR_T)TOLOWER(thisBuffer[i]);
return body;
}

StringBody*
StringBody::ToUpper()
{
if (this->IsEmpty())
return New();

CHAR_T* thisBuffer = StringBuffer();
StringBody* body = New(Length);
CHAR_T* bodyBuffer = body->StringBuffer();

for (int i = 0; i <>Length; ++i)
bodyBuffer[i] = (CHAR_T)TOUPPER(thisBuffer[i]);
return body;
}


//////////////////////////////////////////////////////////
//
// String implementation
// ======
String&
String::Copy(const String& s, int copy)
{
Body->Delete();
Body = copy == DeepCopy ? StringBody::New(s.Body) : s.Body->MakeUse();
return *this;
}

CHAR_T
String::operator [](int i) const
{
return (*Body)[i];
}

CHAR_T&
String::operator [](int i)
{
return const_cast((*Body)[i]);
}

String
String::ToString(CHAR_T c)
{
CHAR_T s[2];

s[0] = c;
s[1] = 0;
return String(s);
}

String
String::ToString(int i)
{
CHAR_T s[16];

#if defined __LINUX
SPRINTF(s, sizeof(s) / sizeof(CHAR_T) - 1, STRING_C("%d"), i);
#else
SPRINTF(s, STRING_C("%d"), i);
#endif
return String(s);
}

String
String::ToString(double d)
{
CHAR_T s[64];

#if defined __LINUX
SPRINTF(s, sizeof(s) / sizeof(CHAR_T) - 1, STRING_C("%lf"), d);
#else
SPRINTF(s, STRING_C("%lf"), d);
#endif
return String(s);
}

String
String::ToString(bool b)
{
return String(b ? STRING_C("true") : STRING_C("false"));
}








#if !defined(__lstring_h)
#define __lstring_h

//[]------------------------------------------------------------------------[]
//| |
//| Object Structural WorkBench Class Library |
//| Version 2.0 |
//| |
//| Copyright® 1999-2004, Paulo Aristarco Pagliosa |
//| All Rights Reserved. |
//| |
//[]------------------------------------------------------------------------[]
//
// OVERVIEW: lstring.h
// ========
// Class definition string.

#include
#include
#include
#include

#if defined __UNICODE
#define CHAR_T wchar_t
#define STRING_C(s) L##s
#if defined __LINUX
#include
#include
#endif
#define STRLEN wcslen
#define STRCPY wcscpy
#define STRNCPY wcsncpy
#define STRCMP wcscmp
#define STRNCMP wcsncmp
#define STRCHR wcschr
#define STRRCHR wcsrchr
#define TOUPPER towupper
#define TOLOWER towlower
#define PRINTF wprintf
#define SPRINTF swprintf
#define VSPRINTF vswprintf
#else
#define CHAR_T char
#define STRING_C(s) s
#if defined __LINUX
#define SPRINTF snprintf
#define VSPRINTF vsnprintf
#else
#define SPRINTF sprintf
#define VSPRINTF vsprintf
#endif
#define STRLEN strlen
#define STRCPY strcpy
#define STRNCPY strncpy
#define STRCMP strcmp
#define STRNCMP strncmp
#define STRCHR strchr
#define STRRCHR strrchr
#define PRINTF printf
#define TOUPPER toupper
#define TOLOWER tolower
#endif

//
// Constants
//
enum
{
ShallowCopy,
DeepCopy
};

//
// Forward definition
//
class StringBody;


//////////////////////////////////////////////////////////
//
// String: string class
// ======
class String
{
public:
// Constructors
String();
String(const String&);
String(const String&, int);
String(const CHAR_T*);
String(const CHAR_T*, int);

// Destructor
~String();

// Assignment
String& Copy(const String&, int = ShallowCopy);
String& operator =(const String&);
String& operator =(CHAR_T);
String& operator =(int);
String& operator =(double);
String& operator =(bool);

// Concatenation
String operator +(const String&) const;
String operator +(CHAR_T) const;
String operator +(int) const;
String operator +(double) const;
String operator +(bool) const;
String& Append(const String&);
String& operator +=(const String&);
String& operator +=(CHAR_T);
String& operator +=(int);
String& operator +=(double);
String& operator +=(bool);

// Comparison
int Compare(const String&) const;
bool operator ==(const String&) const;
bool operator !=(const String&) const;

// Subscripting
CHAR_T operator [](int) const;
CHAR_T& operator [](int);

// Character set searching
int IndexOf(CHAR_T) const;
int LastIndexOf(CHAR_T) const;

// Miscellaneous
operator const CHAR_T*() const;
int Length() const;
String& Reverse();
String& ToLower();
String& ToUpper();

// Static casting
static String ToString(CHAR_T);
static String ToString(int);
static String ToString(double);
static String ToString(bool);

private:
StringBody* Body; // this is the body

// Private constructor
String(StringBody*);

}; // String


//////////////////////////////////////////////////////////
//
// StringBody: string body class
// ==========
class StringBody
{
public:
// Free string body memory
void operator delete(void*, size_t);

private:
int RefCount;
int Length; // string buffer length

static StringBody* EmptyString;

// Constructor
StringBody(int = 0);

// Allocate memory to store a string body
void* operator new(size_t, size_t);

// Is this string body the empty string?
bool IsEmpty() const;

// Static "constructors"
static StringBody* New();
static StringBody* New(StringBody*);
static StringBody* New(int);
static StringBody* New(const CHAR_T*, int);
static StringBody* New(const CHAR_T*);

// Make a shallow-copy of this string body
StringBody* MakeUse();
// Delete this string body
void Delete();

// Get the string buffer of this string body
operator const CHAR_T*() const;
CHAR_T* StringBuffer();

// Get the character of this string body at the specified index
const CHAR_T& operator [](int);

// Get the index within this string body of the specified character
int IndexOf(CHAR_T) const;
int LastIndexOf(CHAR_T) const;

// Append another string body to this string body
StringBody* Append(StringBody*);
// Compare this string body to another
int Compare(StringBody*);
// Reverse the string buffer of this this string buffer
StringBody* Reverse();
// Convert this string body to lowercase
StringBody* ToLower();
// Convert this string body to uppercase
StringBody* ToUpper();

friend class String;

}; // StringBody


//////////////////////////////////////////////////////////
//
// StringBody inline implementation
// ==========
inline void
StringBody::operator delete(void* ptr, size_t)
{
::operator delete(ptr);
}

inline
StringBody::StringBody(int length):
RefCount(1),
Length(length)
{}

inline bool
StringBody::IsEmpty() const
{
return this == EmptyString;
}

inline StringBody*
StringBody::New()
{
return EmptyString->MakeUse();
}

inline StringBody*
StringBody::New(StringBody* s)
{
return s->IsEmpty() ? New() : New(s->StringBuffer(), s->Length);
}

inline StringBody*
StringBody::New(int length)
{
return new(length) StringBody(length);
}

inline StringBody*
StringBody::MakeUse()
{
++RefCount;
return this;
}

inline void
StringBody::Delete()
{
if (!--RefCount)
delete this;
}

inline
StringBody::operator const CHAR_T*() const
{
return reinterpret_cast(this + 1);
}

inline CHAR_T*
StringBody::StringBuffer()
{
return const_cast((const CHAR_T*)*this);
}


//////////////////////////////////////////////////////////
//
// String inline implementation
// ======
inline
String::String()
{
Body = StringBody::New();
}

inline
String::String(const String& s)
{
Body = s.Body->MakeUse();
}

inline
String::String(const String& s, int copy)
{
Body = copy == DeepCopy ? StringBody::New(s.Body) : s.Body->MakeUse();
}

inline
String::String(const CHAR_T* s)
{
Body = StringBody::New(s);
}

inline
String::String(const CHAR_T* s, int len)
{
Body = StringBody::New(s, len);
}

inline
String::String(StringBody* body)
{
Body = body;
}

inline
String::~String()
{
Body->Delete();
}

inline String&
String::operator =(const String& s)
{
return Copy(s);
}

inline String&
String::operator =(CHAR_T c)
{
return operator =(ToString(c));
}

inline String&
String::operator =(int i)
{
return operator =(ToString(i));
}

inline String&
String::operator =(double d)
{
return operator =(ToString(d));
}

inline String&
String::operator =(bool b)
{
return operator =(ToString(b));
}

inline String
String::operator +(const String& s) const
{
return String(Body->Append(s.Body));
}

inline String&
String::Append(const String& s)
{
return operator =(operator +(s));
}

inline String&
String::operator +=(const String& s)
{
return Append(s);
}

inline String&
String::operator +=(CHAR_T c)
{
return Append(ToString(c));
}

inline String&
String::operator +=(int i)
{
return Append(ToString(i));
}

inline String&
String::operator +=(double d)
{
return Append(ToString(d));
}

inline String&
String::operator +=(bool b)
{
return Append(ToString(b));
}

inline int
String::Compare(const String& s) const
{
return Body->Compare(s.Body);
}

inline bool
String::operator ==(const String& s) const
{
return Compare(s) == 0;
}

inline bool
String::operator !=(const String& s) const
{
return !operator ==(s);
}

inline int
String::IndexOf(CHAR_T c) const
{
return Body->IndexOf(c);
}

inline int
String::LastIndexOf(CHAR_T c) const
{
return Body->LastIndexOf(c);
}

inline int
String::Length() const
{
return Body->Length;
}

inline
String::operator const CHAR_T*() const
{
return (const CHAR_T*)*Body;
}

inline String&
String::Reverse()
{
return operator =(String(Body->Reverse()));
}

inline String&
String::ToLower()
{
return operator =(String(Body->ToLower()));
}

inline String&
String::ToUpper()
{
return operator =(String(Body->ToUpper()));
}


#endif

Read more »

Aula 7, no final da Aula 2 [update]

A suposta aula 7, que seria a de hj, eu coloquei no final da Aula 2, "Atributos de métodos e classes"! Por orientação do professor! É uma continuação!
[]'s

Read more »

Arrumei os comentários!

Eu não sei se alguém já tentou comentar alguma coisa aqui, mas agora eu arrumei a parada!

[]'s

Read more »

Aula 6

continuação direta da aula 5
Uma instância de uma classe com métodos virtuais possui em sua estrutura, além dos atributos declarados na classe, um ponteiro para a TPMV da classe(espaço para esse ponteiro é alocado pelo compilador). Por exemplo,

A* pa=new A(); //construtor padrão

|_&A::TPMV_|<-----------|__|pa
|____a_____|


pa=new B();

|_&B::TPMV_|<----------|__|pa
|___A::a____|
|___B::b____|
|___B::c____|


O acoplamento do método à mensagem pa->f(); em C++ é feito da seguinte forma:

• O endereço da TPMV do objeto apontado por "pa" é obtido(é o primeiro campo do objeto);
• O endereço do método a ser acoplado é obtido da TPMV e corresponde à entrada do índice do método virtual f()(neste caso 0(zero));
• Os argumentos do método e "this" são empilhados e o método é finalmente invocado: (*(pa->TPMV[0]))(pa) //(* (endereço de TPMV[índice de f()]))( this)

O grande benefício da junção posterior é cófigo novo funcionando com código velho eliminando construções do tipo switch case, um método Figura2d::Desenha() ilustra isso
class Figura2D
{
private:
Primitivo2D& Primitivo;
int NDPr;
public:
void AdicionaPrimitivo(Primitivo);
void Desenha() const;
Figura2D();
Primitivo(0);
NDPr(0);
};

void Figura2D::Desenha() const
{
for(Primitivo2D* p=Primitivo; p; p=p->Prox)
p->Desenha();
}

O método irá funcionar para qualquer objeto cuja classe derivada de Primitivo2D() e sobrecarregar o método abstrato Primitivo2d::Desenha(). Estamos falando não apenas das classes Linha2D e Círculo2D, mas de qualquer classe derivada de Primitivo2D.
Obs Um método abstrato em c++ é um método virtual puro. Toda classe que declarar pelo menos um métodos abstrato é uma classe abstrata. Uma classe abstrata não admite instância.( Em java, uma classe pode ser declarada abstrata mesmo se possuir um método abstrato, porém, se uma classe possuir um método abstrato, então também deve ser declarado abstrato)

Read more »

Aula 5

Polimorfismo é a capacidade de um operador ou de métodos de um mesmo nome implementar várias operações distintas. Em C++, por exemplo, o operador '+' é usado para adição de dois inteiros, de dois reais, de um real e um inteiro, etc. Em Java, o operador também é usado para concatenação de strings. Além disso, em C++, é possível a sobrecarga de operadores, ou seja, a definição de funções cujo nome é a palavra reservada 'operator' seguida do símbolo do operador(os argumentos da função devem ser compatíveis com o número de argumentos exigidos pelo operador). Assim, pode se escrever em C++
X operator +(const X&, const X&amp;amp;);
Oque aumenta ainda mais o polimorfismo do operador '+' o qual passa a ser usado também para a adição de dois objetos da classe X:
X x1, x2, x3;
.
.
.
x3=x1+x2;
x3=operator+(x1, x2);

css X
{.
.
.
friend X operator+(const X&, const X&amp;amp;);
.
.
.
};


class X
{
public:
X operator+(const X&) const;
.
.
.
};
x3=x1+x2;
x3=x1.operator+(x2);


No caso de polimorfismo envolvendo funções que não sejam operadores, possam ter funções ou métodos com o mesmo identificador mas que são distinguidos pelo número e/ou tipo dos parametros. Como exemplo sejam os métodos da classe A:
Sejam os métodos da classe A:

class A
{
int a;
public:
virtual void f();
void f(int);
void f(int, float);
void f(float, int);
};

Há quatro versões do método f na classe. No exemplo a seguir os métodos acoplados as respectivas mensagens são determinados em tempo de compilação em função do número e/ou tipo dos argumentos da mensagem. Quando o acoplamento mensagem/metódo é resolvido em tempo de compilação é chamado "acoplamento estático" ou "junção anterior".

A a;
a.f(); //A::f()
a.f(2); //A::f(int)
a.f(2, 3); //O compilador não sabe, não há um método f(int, int)

Na classe A tinhamos quatro versões de um método declarado, ou seja, uma instância de A pode responder a quatro tipos distintos de mensagens cujo seletor é f. A uma outra faceta de polimorfismo relacionada com o mecanismo de herança. Uma classe derivada, pode redefinir um método de uma classe base, com o mesmo identificador, como mesmo tipo de identificador, mesmo tipo de retorno e um corpo que pode ser diferente. Isto é feito na classe B a seguir, derivada da classe A:

class B: public A
{
int b, c;
public:
void f();
void f(int);
};

Note que uma instância de B pode responder a 6 mensagens cujo seletor é f, quatro para métodos herdados de A, e dois para métodos redefinidos em B.
Em C++ para mensagens enviadas a um objeto criado estáticamente, o acoplamento sempre será estático como no exemplo abaixo:

B b;
b.f(); //B::f()
b.f(2); //B::f(int)
b.A::f() //A::f() Nome qualificado

**** IMPORTANTÍSSIMO ****
As coisas mudam quando uma mensagem é enviada a um objeto através de um ponteiro. Em C++ e em Java um ponteiro para uma classe base pode receber um endereço de um objeto desta classe ou de qualquer classe que dela derivada direta ou indiretamente. Assim, se tivermos

A* pa;
.
.
.
pa->f(); //A::f()

podemos nos perguntar qual método será acoplado à mensagem, uma vez que o ponteiro pa pode receber o endereço de um objeto da classe A, da classe B ou de qualquer outra que derive de A. A resposta a essa questão depende do método A::f() ser virtual ou não:

• Se o método não for virtual, então A::f() será acoplado(independentemente do tipo do objeto cujo endereço é atribuido a pa), uma vez que pa é um ponteiro para a classe A, ou seja, o acoplamento é estático(determinado em tempo de compilação). [Se não for virtual vai ser estático, foda-se oque aconteça. Nota do professor]
• Se um método for virtual então o método a se acoplado a mensagem será aquele da classe do objeto cujo endereço, em tempo de execução, for atribuido a pa. Este tipo de acoplamento é chamado "acoplamento dinâmico" ou" junção posterior", pois é resolvido em tempo de execução.

**********************

Observações:

1. Em uma classe derivada a redefinição de um método não virtual herdado de uma classe base esconde um método da classe base. A redefinição de um método virtual na classe derivada sobrecarrega um método da base.
2. Em Java, todos os métodos não estáticos são virtuais.
3. Acoplamento dinâmico tem um custo em termos de eficiência. Em C++ a junção posterior é implementada através de tabelas de ponteiros de métodos virtuais(TPMV). Toda classe que tiver declarado pelo menos um método virtual terá associada uma tabela cujas entradas serão os endereços do código de cada uma das funções virtuais declaradas na classe. Toda função virtual possui como atributo um índice para a entrada correspondente na TPMV de sua classe. A TPMV de uma classe derivada copia a TPMV de sua classe base, ajustando as entradas para apontar para aqueles métodos que foram sobrecarregados e foram adicionando novas entradas se novos métods virtuais forem declarados da classe derivada. Por exemplo a TPMV da classe A é:

A
0| &A::f() |
1 | &A::f(int, float) |

A TPMV da classe B é:
B
0 | &B::f() |
1 | &amp;amp;A::f(int, float) |
2 | &B::k() |

Read more »

Apostilas sobre Java!

Seguinte pessoal, tenho aqui comigo algumas apostilas sobre Java que poderiam vir a ser interessantes, eu não li direito nenhuma, mas se tiver alguém afim, eu upo elas pra algum lugar.
As apostilas são:

1. O que é Java?
2. JavaScript
3. Apostila JAVA
4. Guia de Referência
5. Exemplos(obviamente de Java)

Mais uma vez, se alguém se mostrar interessado eu as disponibilizarei!

Também tenho apostilas de Algoritmos, VB, Access, ASP, Assembly, BD, C, CGI, Clipper, Delphi, Design Gráfico, Eng. de Soft. , Hardware, HTML, Internet, JSP, Office, Pascal, Perl, PHP, Python, Rede, Segurança, SO, StarOffice e Unix. Vale lembrar que eu não li nenhuma delas!

Qualquer coisa, jamildagher@gmail.com

Read more »

Aula 4

Exemplo de polimorfismo:

class A
{
int a;
public:
void f();
void f(int);
void f(int, float);
void f(float, int);
};

A a;
a.f(); //A::f()
a.f(2); //A::f(int)
a.f(2, 3); //O compilador não sabe, não há um método f(int, int)


class B: public A
{
int b, c;
public:
void f();
void f(int);
};


B b;
b.f(); //B::f()
b.f(2); //B::f(int)
b.A::f() //A::f() Nome qualificado

class A
{
public:
virtual void f();
void f(int);
void f(in, float);
void f(float, int);
}; //Não alterou as respostas

retorna a classe A sem o virtual void
A* pa;
.
.
.
pa->f(); //A::f()


B* bp;
.
.
.
bp->f(); //B::f()




//Exemplos

class Primitivo2D
{
public:
virtual void Desenha() cont=0;
private:
Primitivo2D* Prox;
friend class Figura2D;
};

class Linha2D: public Primitivo2D
{
public:
void Desenha() const;
.
.
.
};

class Circulo2D: public Primitivo2D
{
public:
void Desenha() const;
.
.
.
};

class Figura2D
{
private:
Primitivo2D& Primitivo;
int NDPr;
public:
void AdicionaPrimitivo(Primitivo);
void Desenha() const;
Figura2D();
Primitivo(0);
NDPr(0);
};

void Figura2D::Desenha() const
{
for(Primitivo2D* p=Primitivo; p; p=p->Prox)
p->Desenha();
}


//void main
Figura2D f;
f.AdicionaPrimitivo(new Linha2D(...));
f.AdicionaPrimitivo(new Circulo2D(...));
.
.
.
f.Desenha();

void Figfura2D::AdicionaPrimitivo(Primitivo2D* p)
{
p->Prox=Primitivo;
Primitivo=p;
++NDPr;
}

Read more »

Aula 3 já corrigida!

A PARTE ERRADA JÁ FOI CORRIGIDA. Agradecimentos a Letrícia e a Cristiane.

O desenho eu irei mudá-lo assim que me vier uma inspiração, por enquanto fica esse desenho em ASCII tosco!
Abraço a todos! E espero estar ajudando!

Read more »

Aula 3

-> Propriedades da Orientação e Objeto

• Encapsulamento

Encapsular significa esconder, na definição de uma classe os membros que representam a estrutura e o comportamento interno dos objetos da classe. Geralmente são escondidos todos os atributos enquanto os métodos são tornados publicos. Entretanto pode-se esconder também métodos bem como tornar públicos atributos. Tudo depende do projeto e do bom senso.

"Esconder um membro" em C++ significa declaralo na sessão privada(private) ou protegida(protected) da classe. Um membro privado só pode ser acessado em métodos da prórpia classe onde foi declarado. Membros protegidos podem ser acessados por métodos da própria classe e de classes derivadas publicamente da classe onde foi declarada. Membros públicos podem ser acessados por quaisquer métodos e definem a interface da classe.

Para um atributo privado ou protegido o acesso a este só pode ser efetuado por métodos quaisquer indiretamente, através de métodos declarados na classe do atributo chamados "setters" e "getters". Um setter é utilizado para atribuição de um novo valor para um atributo, enquanto um getter é utilizado para a obtenção de um valor.

Um atributo para o qual há um getter e um setter é uma propriedade do objeto. Embora aconselhável esconder um atributo, seu acesso por getters e setters(ou seja, funções) podem acrescentar ineficiência ao sistema. Em C++ tal ineficiência é evitada com o uso de métodos "in-line". Em uma mensagem na qual o método in-line é aclopado, não há um overhead(custo) de uma chamada de função. Ao invés disso o corpo do métodos é expandido em linha no local da mensagem. Com isso o código gerado fica maior dependendo do tamanho do corpo do método corrente, por isso, métodos in-line tem que ser criteriosamente usados. Em C++ todo método implementado dentro de sua classe é inline. Métodos implementados fora da classe tem que ser explicitamente declarados com a palavra inline. De fato o compilador tenta fazer o método in-line se possível ( Ou seja, nem todo método declarado in-line é efetivamente inline ).

As vantagens do encapsulamento são:

1. Melhor organização do cógigo.
2. Alterações em membros encapsulados de uma classe não são refletidas nos métodos de outros objetos usuários da classe(a não ser que essas alterações modifiquem a interface da classe).

• Herança

Mecanismo através do qual um objeto de uma classe Y herda todos os membros de uma classe X. A classe X é chamada SuperClasse(ou classe Base em C++) e a classe Y é chamada SubClasse ou classe Derivada. Uma classe Base representa uma generalização, uma classe Derivada representa uma especialização. Em UML(Unified Modeling Language, Linguagem de Modelagem Unificada) a representação mais simples de uma classe é um retângulo com o nome da classe dentro. Um relacionamento do tipo generalização/especialização entre duas classes é expresso em UML através do seguinte diagrama de classe:
..__
| X |
../ ...|
..__
| Y |

Há quatro maneiras de uma classe Derivada especializar uma classe Base:

1. Adicionando novos atributos
2. Adicionando novos métodos
3. Redefinindo a implementação de métodos herdados da classe Base
4. Não fazendo nada

O grande benefício da herança é reutilização de código.
Obs. Ao contrário de Java, C++ admite herança multipla, isto é, uma classe pode ser Derivada de duas ou mais classes Bases.

• Polimorfismo(várias formas)

Read more »

Aula 2

Aula 02

Exemplo
{
X x;
}

Alocação Dinâmica

Em C++ um objeto é criado dinâmicamente, com o operador new o qual retorna o endereço da região de memória do primeiro byte ocupado pelo objeto.

X* p=new X(); ou X *p=new X;

Objetos criados dinâmicamente residem no heap do sistema,que é a área destinada a um programa pelo SO(sistema operacional) para alocação dinâmica(em tempo de execução de memória). Ao contrário de objetos estáticos, os objetos criados dinâmicamente devem ser explicitamente destruidos, através do operador delete. Ao contrário de new, delete invoca o destrutor e em seguida libera a memória do heap ocupada pelo objeto.

delete p;

Obs. Manipulação explicita de ponteiros é uma das causas mais comuns de erros em C++(coisa que não existe em Java).

O tempo de vida útil de um objeto começa imediatamente após sua criação e dura até o instante imediatamente antes de sua instrução. Durante sua vida útil o objeto pode ser usado de duas maneiras:

1- Acessando um atributo do objeto:

int a=x.a; //acesso de leitura: x.a é um rvalue (valor que esta dp lado direito, não pode ser modificado)
p->a=a; //acesso de escrita: p->a é um lvalue (trabalha com o endereço)
//mesma coisa que a de cima (*p).a=a;

2- Enviando uma mensagem para o objeto:

x.m();
p->m();

Como resposta à mensagem o receptor acopla o método

X::m() //X(qualificador) e X::m(nome qualificado).

Acoplar significa: descobrir na classe do receptor um método cujo nome é o mesmo do seletor da mensagem e cujos parâmetros casam em número e tipo com os argumentos da mensagem, e em seguida invocar tal método. Sintaticamente enviar uma mensagem é similar a acessar um atributo, com a diferença que depois do nome do método vem o par de parênteses com os argumentos da mensagem em seu interior. É como se estivessemos chamando um função para um objeto. Semânticamente porém deve se ter em mente que se esta enviando uma mensagem e que a função a ser invocada é consequência do acoplamento.

Obs. X::m é um nome qualificado sendo o nome simples 'm' o nome de um método(o nome simples de um nome qualificado pode ser o nome de qualquer membro de uma classe). O qualificador de um nome qualificado é um nome de classe que precede o operador de escopo, nesse caso o 'X'. “m é da classe X”

Em C++, o operador de escopo ::a é um nome totalmente qualificado, sendo 'a' um nome declarado globalmente(o qualificador é nulo).

Exemplo
int a;
void f(int a)
{
::a=a;
}

Propriedades da Orientação e Objeto

-> Encapsulamento
-> Herança
-> Polimorfismo

Atributos de Métodos de Classes

Ao contrário de atributo de instância,um atributo de classe não pertence à estrutura de dados de objetos da classe. Há apenas uma cópia do atributo(que pode ser intendido como sendo de propriedade da classe) ao invés de uma cópia para cada objeto da classe. Os objetos da classe compartilham esta cópia única. Em C++ um atributo de classe é definido como modificador "static".

Obs Em C++ a variável uma variável estática declarada em uma classe(geralmente em uma arquivo .h) é definida em um arquivo .cpp.

//
//Início do x.h
//
#include

class X
{
public:
int a, b;
static int sa; //atributo de classe

void f()
{
a=sa;
}

};

//
//Fim do x.h
//

//
//Início do x.cpp
//
#include "x.h"

int X::sa=4;
int main()
{
X x1, x2;
int a=x1.a;

a=X::sa;
x1.sa=3;
printf("Tamanho de x: %d, valor de X::sa: \n", sizeof(x1), X2.sa);
return 0;
}

//
//Fim do x.cpp
//

Um método de classe:

• não pode ser invocado como resultado do acoplamento mensagem método.
  
• não pode acessar atributos de instância de "this"(Não é possível usar this em um método de classe).
  
• é como se fosse uma função global pertencente à classe. Em C++ um método de classe é declarado como modificador "static".

Tratamento de Exceções

O tratamento de exceções constitui-se em:

1. Lançamento da exceção. Quando um método verifica a ocorrência de uma situação excepcional, este pode lançar uma exceção. Lançar uma exceção significa criar um objeto que transportará em seus atributos(conforme definido em sua classe) com as informações relevantes sobre a exceção detectada. Uma vez criado este objeto ele é lançado em uma sentença "throw". Em C++ uma exceção pode ser um objeto de qualquer tipo. Em Java uma exceção é uma instância que o objeto da classe "Exception" ou dela derivado. O código abaixo da sentença "throw" não é executado quando no lançamento da exceção.
   
2. Tratamento da exceção propriamente dito. Todo código em que uma exceção pode ocorrer deve ser enclausurado em um bloco "try". Se em algum ponto do "try" uma exceção for lançada, o código restante após o ponto de lançamento não é executado. Após o bloco "try" deve se ter uma ou mais blocos "catch", parametrizados cada um deles com um dos tipos de exceção que podem ocorrer no "try". Na ocorrência de uma exceção o fluxo de controle é transferido para o primeiro bloco "catch" cujo parâmetro é do tipo da exceção lançada. O código do "catch" efetua o tratamento da exceção, e o fluxo de controle é desviado para o código após o último "catch". Senão houver um "catch" para o tipo de exceção lançada uma função global de tratamento de exceções invocadas é chamada(geralmente esta aborta a execução do programa). O exemplo a seguir ilustra:
   

#include
void* malloc(size_t);

struct my_out_of_memory
{
my_out_of_memory(size_t size)
{
this->size=size;
}//end myoutofsize
size_t size;
};

void* my_alloc(size_t size)
{

void* ptr=malloc(size);

if(ptr==NULL)
{
throw my_out_of_memory(size);
}//endif

return ptr;

}//end voidmyalloc

void q()
{

void* b1=NULL;
void* b2=NULL;
void* b3=NULL;

try
{
void* b1= my_malloc(1000);
void* b2= my_malloc(3000);
void* b3= my_malloc(4000);
//faça ago
}//end try

catch(my_out_of_memory& e)
{
printf("out of memory(%d bytes)\n", e.size);
}//end catch

free(b1);
free(b2);
free(b3);

}//end voidq

Read more »