Well, why don't we try it and see?  

ops$tkyte@ORA817DEV.US.ORACLE.COM> create table t ( x int );
Table created.

ops$tkyte@ORA817DEV.US.ORACLE.COM> insert into t values ( 1 );
1 row created.

ops$tkyte@ORA817DEV.US.ORACLE.COM> commit;
Commit complete.

ops$tkyte@ORA817DEV.US.ORACLE.COM> declare
  2      l_start number;
  3  
  4      cursor c1 is select * from t;
  5      n      number;
  6  begin
  7      l_start := dbms_utility.get_time;
  8      for i in 1 .. 1000
  9      loop
 10          open c1;
 11          loop
 12              fetch c1 into n;
 13              exit when c1%notfound;
 14          end loop;
 15          close c1;
 16  
 17          -- now lets simulate a SELECT into as well
 18  
 19          open c1;
 20          fetch c1 into n;
 21          if ( c1%notfound ) then raise NO_DATA_FOUND; end if;
 22          fetch c1 into n;
 23          if ( c1%found ) then raise TOO_MANY_ROWS; end if;
 24          close c1;
 25  
 26      end loop;
 27      dbms_output.put_line( (dbms_utility.get_time-l_start) || ' hsecs' );
 28  
 29      l_start := dbms_utility.get_time;
 30      for i in 1 .. 1000
 31      loop
 32          for x in ( select * from t )
 33          loop
 34              null;
 35          end loop;
 36  
 37          select * into n from t;
 38      end loop;
 39      commit;
 40      dbms_output.put_line( (dbms_utility.get_time-l_start) || ' hsecs' );
 41  end;
 42  /
54 hsecs
42 hsecs

PL/SQL procedure successfully completed.


Ok, so what we have is:

o it takes more code to write explicit cursors
o it is more error prone, you must remember to open them, close them
o you have to declare all of the variables all of the time (nothing 
  like a cursor for loop for ease of programming if you ask me)
o they are measurably slower


Well, I haven't found anything good to say about them.  I'm a polarized sort of guy -- far too many people believe the total opposite, that EXPLICIT cursors are the only way to program.  I'm on a crusade to put that myth to rest, along with the myths that

o more then a single digit number of extents is bad (false)

o the most discriminating fields should be on the leading edge of an index (depends)

o you don't need to understand the database, its just a black box (totally false)

o explicit cursors are faster then implicit (provably false)

and so on.
I figure people are going to pick one or the other here -- implicit or explicit.  They should pick implicit, period, plain and simple.

 

ops$tkyte@ORA9IR2> declare
  2          cursor c is select * from dual;
  3          l_dummy dual.dummy%type;
  4  begin
  5          open c;
  6          loop
  7                  fetch c into l_dummy;
  8                  exit when c%notfound;
  9          end loop;
 10          dbms_output.put_line( c%rowcount || ' rows processed' );
 11          close c;
 12  end;
 13  /
1 rows processed

PL/SQL procedure successfully completed.


use c%rowcount after the loop to see how many rows processed.  If zero, do whatever.