X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=pod%2Fperltoot.pod;h=e6aa3de60bf0fac407bf6e05d43ec05a32a5e72f;hb=b851fbc1add6c3d9fa6158884279133c311a3efc;hp=c23591245a919157451c716ce2f037846e1e664c;hpb=54310121b442974721115f93666234a200f5c7e4;p=p5sagit%2Fp5-mst-13.2.git diff --git a/pod/perltoot.pod b/pod/perltoot.pod index c235912..e6aa3de 100644 --- a/pod/perltoot.pod +++ b/pod/perltoot.pod @@ -89,7 +89,7 @@ the same name as the class as the constructor. =head2 Object Representation By far the most common mechanism used in Perl to represent a Pascal -record, a C struct, or a C++ class an anonymous hash. That's because a +record, a C struct, or a C++ class is an anonymous hash. That's because a hash has an arbitrary number of data fields, each conveniently accessed by an arbitrary name of your own devising. @@ -111,8 +111,8 @@ by up-casing the hash keys: PEERS => [ "Norbert", "Rhys", "Phineas"], }; -And so you could get at C<$rec-E{NAME}> to find "Jason", or -C<@{ $rec-E{PEERS} }> to get at "Norbert", "Rhys", and "Phineas". +And so you could get at C<< $rec->{NAME} >> to find "Jason", or +C<< @{ $rec->{PEERS} } >> to get at "Norbert", "Rhys", and "Phineas". (Have you ever noticed how many 23-year-old programmers seem to be named "Jason" these days? :-) @@ -267,6 +267,9 @@ Because while a constructor is explicitly called, a destructor is not. Destruction happens automatically via Perl's garbage collection (GC) system, which is a quick but somewhat lazy reference-based GC system. To know what to call, Perl insists that the destructor be named DESTROY. +Perl's notion of the right time to call a destructor is not well-defined +currently, which is why your destructors should not rely on when they are +called. Why is DESTROY in all caps? Perl on occasion uses purely uppercase function names as a convention to indicate that the function will @@ -312,7 +315,7 @@ be made through methods. Perl doesn't impose restrictions on who gets to use which methods. The public-versus-private distinction is by convention, not syntax. (Well, unless you use the Alias module described below in -L.) Occasionally you'll see method names beginning or ending +L.) Occasionally you'll see method names beginning or ending with an underscore or two. This marking is a convention indicating that the methods are private to that class alone and sometimes to its closest acquaintances, its immediate subclasses. But this distinction @@ -326,7 +329,7 @@ do more than fetch or set one particular field. sub exclaim { my $self = shift; return sprintf "Hi, I'm %s, age %d, working with %s", - $self->{NAME}, $self->{AGE}, join(", ", $self->{PEERS}); + $self->{NAME}, $self->{AGE}, join(", ", @{$self->{PEERS}}); } Or maybe even one like this: @@ -422,6 +425,10 @@ this could be done: Notice how there's no memory to deallocate in the destructor? That's something that Perl takes care of for you all by itself. +Alternatively, you could use the Class::Data::Inheritable module from +CPAN. + + =head2 Accessing Class Data It turns out that this is not really a good way to go about handling @@ -539,7 +546,7 @@ and DESTROY methods as follows: } What happens if a derived class (which we'll call Employee) inherits -methods from this Person base class? Then Cdebug()>, when called +methods from this Person base class? Then C<< Employee->debug() >>, when called as a class method, manipulates $Person::Debugging not $Employee::Debugging. =head2 Class Destructors @@ -796,7 +803,7 @@ base class. If the original base class has been designed properly, then the new derived class can be used as a drop-in replacement for the old one. This means you should be able to write a program like this: - use Employee + use Employee; my $empl = Employee->new(); $empl->name("Jason"); $empl->age(23); @@ -813,7 +820,7 @@ What do we mean by the Person::new() function -- isn't that actually a method? Well, in principle, yes. A method is just a function that expects as its first argument a class name (package) or object (blessed reference). Person::new() is the function that both the -Cnew()> method and the Cnew()> method end +C<< Person->new() >> method and the C<< Employee->new() >> method end up calling. Understand that while a method call looks a lot like a function call, they aren't really quite the same, and if you treat them as the same, you'll very soon be left with nothing but broken programs. @@ -1121,8 +1128,7 @@ it happens when you say If you wanted to add version checking to your Person class explained above, just add this to Person.pm: - use vars qw($VERSION); - $VERSION = '1.1'; + our $VERSION = '1.1'; and then in Employee.pm could you can say @@ -1360,7 +1366,7 @@ constructor will look like when taking this approach: package Person; use Carp; - use vars qw($AUTOLOAD); # it's a package global + our $AUTOLOAD; # it's a package global my %fields = ( name => undef, @@ -1430,8 +1436,7 @@ Here's how to be careful: package Employee; use Person; use strict; - use vars qw(@ISA); - @ISA = qw(Person); + our @ISA = qw(Person); my %fields = ( id => undef, @@ -1467,12 +1472,12 @@ as detailed above. Perl programmers have responded to this by creating several different class construction classes. These metaclasses are classes that create other classes. A couple worth looking at are -Class::Template and Alias. These and other related metaclasses can be +Class::Struct and Alias. These and other related metaclasses can be found in the modules directory on CPAN. -=head2 Class::Template +=head2 Class::Struct -One of the older ones is Class::Template. In fact, its syntax and +One of the older ones is Class::Struct. In fact, its syntax and interface were sketched out long before perl5 even solidified into a real thing. What it does is provide you a way to "declare" a class as having objects whose fields are of a specific type. The function @@ -1481,11 +1486,11 @@ structures or records are not base types in Perl, each time you want to create a class to provide a record-like data object, you yourself have to define a new() method, plus separate data-access methods for each of that record's fields. You'll quickly become bored with this process. -The Class::Template::struct() function alleviates this tedium. +The Class::Struct::struct() function alleviates this tedium. Here's a simple example of using it: - use Class::Template qw(struct); + use Class::Struct qw(struct); use Jobbie; # user-defined; see below struct 'Fred' => { @@ -1520,7 +1525,7 @@ act like structs in the C sense. printf "perl.com's real name is %s, address %s\n", $h->name, inet_ntoa($h->addr); -Here's how to do this using the Class::Template module. +Here's how to do this using the Class::Struct module. The crux is going to be this call: struct 'Net::hostent' => [ # note bracket @@ -1544,7 +1549,7 @@ We could also have implemented our object this way: addr_list => '@', }; -and then Class::Template would have used an anonymous hash as the object +and then Class::Struct would have used an anonymous hash as the object type, instead of an anonymous array. The array is faster and smaller, but the hash works out better if you eventually want to do inheritance. Since for this struct-like object we aren't planning on inheritance, @@ -1557,19 +1562,20 @@ Here's the whole implementation: BEGIN { use Exporter (); - use vars qw(@ISA @EXPORT @EXPORT_OK %EXPORT_TAGS); - @ISA = qw(Exporter); - @EXPORT = qw(gethostbyname gethostbyaddr gethost); - @EXPORT_OK = qw( - $h_name @h_aliases - $h_addrtype $h_length - @h_addr_list $h_addr - ); - %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] ); + our @EXPORT = qw(gethostbyname gethostbyaddr gethost); + our @EXPORT_OK = qw( + $h_name @h_aliases + $h_addrtype $h_length + @h_addr_list $h_addr + ); + our %EXPORT_TAGS = ( FIELDS => [ @EXPORT_OK, @EXPORT ] ); } - use vars @EXPORT_OK; + our @EXPORT_OK; + + # Class::Struct forbids use of @ISA + sub import { goto &Exporter::import } - use Class::Template qw(struct); + use Class::Struct qw(struct); struct 'Net::hostent' => [ name => '$', aliases => '@', @@ -1582,7 +1588,7 @@ Here's the whole implementation: sub populate (@) { return unless @_; - my $hob = new(); # Class::Template made this! + my $hob = new(); # Class::Struct made this! $h_name = $hob->[0] = $_[0]; @h_aliases = @{ $hob->[1] } = split ' ', $_[1]; $h_addrtype = $hob->[2] = $_[2]; @@ -1615,9 +1621,10 @@ Here's the whole implementation: We've snuck in quite a fair bit of other concepts besides just dynamic class creation, like overriding core functions, import/export bits, -function prototyping, and short-cut function call via C<&whatever>. -These all mostly make sense from the perspective of a traditional module, -but as you can see, we can also use them in an object module. +function prototyping, short-cut function call via C<&whatever>, and +function replacement with C. These all mostly make +sense from the perspective of a traditional module, but as you can see, +we can also use them in an object module. You can look at other object-based, struct-like overrides of core functions in the 5.004 release of Perl in File::stat, Net::hostent, @@ -1655,7 +1662,7 @@ update value fields in the hash. Convenient, eh? } use Alias qw(attr); - use vars qw($NAME $AGE $PEERS); + our ($NAME, $AGE, $PEERS); sub name { my $self = attr shift; @@ -1686,7 +1693,7 @@ update value fields in the hash. Convenient, eh? return ++$AGE; } -The need for the C declaration is because what Alias does +The need for the C declaration is because what Alias does is play with package globals with the same name as the fields. To use globals while C is in effect, you have to predeclare them. These package variables are localized to the block enclosing the attr() @@ -1695,9 +1702,9 @@ they're still considered global variables with temporary values, just as with any other local(). It would be nice to combine Alias with -something like Class::Template or Class::MethodMaker. +something like Class::Struct or Class::MethodMaker. -=head2 NOTES +=head1 NOTES =head2 Object Terminology @@ -1724,7 +1731,7 @@ as a class or object method is by usage only. You could accidentally call a class method (one expecting a string argument) on an object (one expecting a reference), or vice versa. -Z<>From the C++ perspective, all methods in Perl are virtual. +From the C++ perspective, all methods in Perl are virtual. This, by the way, is why they are never checked for function prototypes in the argument list as regular builtin and user-defined functions can be. @@ -1747,27 +1754,31 @@ L, and L. -=head1 COPYRIGHT +L is a kinder, gentler introduction to object-oriented +programming. + +L provides more detail on class data. + +Some modules which might prove interesting are Class::Accessor, +Class::Class, Class::Contract, Class::Data::Inheritable, +Class::MethodMaker and Tie::SecureHash -I I hate to have to say this, but recent unpleasant -experiences have mandated its inclusion: - - Copyright 1996 Tom Christiansen. All Rights Reserved. - -This work derives in part from the second edition of I. -Although destined for release as a manpage with the standard Perl -distribution, it is not public domain (nor is any of Perl and its docset: -publishers beware). It's expected to someday make its way into a revision -of the Camel Book. While it is copyright by me with all rights reserved, -permission is granted to freely distribute verbatim copies of this -document provided that no modifications outside of formatting be made, -and that this notice remain intact. You are permitted and encouraged to -use its code and derivatives thereof in your own source code for fun or -for profit as you see fit. But so help me, if in six months I find some -book out there with a hacked-up version of this material in it claiming to -be written by someone else, I'll tell all the world that you're a jerk. -Furthermore, your lawyer will meet my lawyer (or O'Reilly's) over lunch -to arrange for you to receive your just deserts. Count on it. + +=head1 AUTHOR AND COPYRIGHT + +Copyright (c) 1997, 1998 Tom Christiansen +All rights reserved. + +This documentation is free; you can redistribute it and/or modify it +under the same terms as Perl itself. + +Irrespective of its distribution, all code examples in this file +are hereby placed into the public domain. You are permitted and +encouraged to use this code in your own programs for fun +or for profit as you see fit. A simple comment in the code giving +credit would be courteous but is not required. + +=head1 COPYRIGHT =head2 Acknowledgments