Place the xp cd in your cd/dvd drive
Go to start
run
type in ‘sfc /scannow’ (without the ‘)

Now it should all load, and fix all your corrupted file on windows XP

copy what’s in the code area to notepad and save as cmd here.reg

CODE

Windows Registry Editor Version 5.00

[HKEY_CLASSES_ROOT\Drive\shell\cmd]
@=”Command Prompt”

[HKEY_CLASSES_ROOT\Drive\shell\cmd\command]
@=”cmd.exe /k \”cd %L\”"

[HKEY_CLASSES_ROOT\Directory\shell\cmd]
@=”Command Prompt”

[HKEY_CLASSES_ROOT\Directory\shell\cmd\command]
@=”cmd.exe /k \”cd %L\”"

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID\{20D04FE0-3AEA-1069-A2D8-08002B30309D}\shell\cmd]
@=”Command Prompt”

[HKEY_LOCAL_MACHINE\SOFTWARE\Classes\CLSID\{20D04FE0-3AEA-1069-A2D8-08002B30309D}\shell\cmd\command]
@=”cmd.exe /k \”cd %L\”"

# Description

110 Restart marker reply. In this case, the text is exact and not left to the particular implementation; it must read: MARK yyyy = mmmm where yyyy is User-process data stream marker, and mmmm server’s equivalent marker (note the spaces between markers and “=”).

120 Service ready in nnn minutes.

125 Data connection already open; transfer starting.

150 File status okay; about to open data connection.

200 Command okay.

202 Command not implemented, superfluous at this site.

211 System status, or system help reply.

212 Directory status.

213 File status.

214 Help message.On how to use the server or the meaning of a particular non-standard command. This reply is useful only to the human user.

215 NAME system type. Where NAME is an official system name from the list in the Assigned Numbers document.

220 Service ready for new user.

221 Service closing control connection.

225 Data connection open; no transfer in progress.

226 Closing data connection. Requested file action successful (for example, file transfer or file abort).

227 Entering Passive Mode (h1,h2,h3,h4,p1,p2).

230 User logged in, proceed. Logged out if appropriate.

250 Requested file action okay, completed.

257 “PATHNAME” created.

331 User name okay, need password.

332 Need account for login.

350 Requested file action pending further information

421 Service not available, closing control connection.This may be a reply to any command if the service knows it must shut down.

425 Can’t open data connection.

426 Connection closed; transfer aborted.

450 Requested file action not taken.

451 Requested action aborted. Local error in processing.

452 Requested action not taken. Insufficient storage space in system.File unavailable (e.g., file busy).

500 Syntax error, command unrecognized. This may include errors such as command line too long.

501 Syntax error in parameters or arguments.

502 Command not implemented.

503 Bad sequence of commands.

504 Command not implemented for that parameter.

530 Not logged in.

532 Need account for storing files.

550 Requested action not taken. File unavailable (e.g., file not found, no access).

551 Requested action aborted. Page type unknown.

552 Requested file action aborted. Exceeded storage allocation (for current directory or dataset).

553 Requested action not taken. File name not allowed.

— B —
BFG – BFG Technologies
BIOS – Basic Input Output System
BNC – Barrel Nut Connector

— C —
CAS – Column Address Signal
CD – Compact Disk
CDR – Compact Disk Recorder
CDRW – Compact Disk Re-Writer
CD-ROM – Compact Disk – Read Only Memory
CFM – Cubic Feet per Minute (ft /min)
CMOS – Complementary Metal Oxide Semiconductor
CPU – Central Processing Unit
CTX – CTX Technology Corporation (Commited to Excellence)

— D —

DDR – Double Data Rate
DDR-SDRAM – Double Data Rate – Synchronous Dynamic Random Access Memory
DFI – DFI Inc. (Design for Innovation)
DIMM – Dual Inline Memory Module
DRAM – Dynamic Random Access Memory
DPI – Dots Per Inch
DSL – See ASDL
DVD – Digital Versatile Disc
DVD-RAM – Digital Versatile Disk – Random Access Memory

— E —
ECC – Error Correction Code
ECS – Elitegroup Computer Systems
EDO – Extended Data Out
EEPROM – Electrically Erasable Programmable Read-Only Memory
EPROM – Erasable Programmable Read-Only Memory
EVGA – EVGA Corporation

— F —
FC-PGA – Flip Chip Pin Grid Array
FDC – Floppy Disk Controller
FDD – Floppy Disk Drive
FPS – Frame Per Second
FPU – Floating Point Unit
FSAA – Full Screen Anti-Aliasing
FS – For Sale
FSB – Front Side Bus

— G —
GB – Gigabytes
GBps – Gigabytes per second or Gigabits per second
GDI – Graphical Device Interface
GHz – GigaHertz

— H —
HDD – Hard Disk Drive
HIS – Hightech Information System Limited
HP – Hewlett-Packard Development Company
HSF – Heatsink-Fan

— I —
IBM – International Business Machines Corporation
IC – Integrated Circuit
IDE – Integrated Drive Electronics
IFS- Item for Sale
IRQ – Interrupt Request
ISA – Industry Standard Architecture
ISO – International Standards Organization

— J —
JBL – JBL (Jame B. Lansing) Speakers
JVC – JVC Company of America

- K —
Kbps – Kilobits Per Second
KBps – KiloBytes per second

— L —
LG – LG Electronics
LAN – Local Are Network
LCD – Liquid Crystal Display
LDT – Lightning Data Transport
LED – Light Emitting Diode

— M —
MAC – Media Access Control
MB   MotherBoard or Megabyte
MBps – Megabytes Per Second
Mbps – Megabits Per Second or Megabits Per Second
MHz – MegaHertz
MIPS – Million Instructions Per Second
MMX – Multi-Media Extensions
MSI – Micro Star International

— N —
NAS – Network Attached Storage
NAT – Network Address Translation
NEC – NEC Corporation
NIC – Network Interface Card

— O —
OC – Overclock (Over Clock)
OCZ – OCZ Technology
OEM – Original Equipment Manufacturer

— P —
PC – Personal Computer
PCB – Printed Circuit Board
PCI – Peripheral Component Interconnect
PDA – Personal Digital Assistant
PCMCIA – Peripheral Component Microchannel Interconnect Architecture
PGA – Professional Graphics Array
PLD – Programmable Logic Device
PM – Private Message / Private Messaging
PnP – Plug ‘n Play
PNY – PNY Technology
POST – Power On Self Test
PPPoA – Point-to-Point Protocol over ATM
PPPoE – Point-to-Point Protocol over Ethernet
PQI – PQI Corporation
PSU – Power Supply Unit

— R —
RAID – Redundant Array of Inexpensive Disks
RAM – Random Access Memory
RAMDAC – Random Access Memory Digital Analog Convertor
RDRAM – Rambus Dynamic Random Access Memory
ROM – Read Only Memory
RPM – Revolutions Per Minute

— S —
SASID – Self-scanned Amorphous Silicon Integrated Display
SCA – SCSI Configured Automatically
SCSI – Small Computer System Interface
SDRAM – Synchronous Dynamic Random Access Memory
SECC – Single Edge Contact Connector
SODIMM – Small Outline Dual Inline Memory Module
SPARC – Scalable Processor ArChitecture
SOHO – Small Office Home Office
SRAM – Static Random Access Memory
SSE – Streaming SIMD Extensions
SVGA – Super Video Graphics Array
S/PDIF – Sony/Philips Digital Interface

— T —
TB – Terabytes
TBps – Terabytes per second
Tbps – Terabits per second
TDK – TDK Electronics
TEC – Thermoelectric Cooler
TPC – TipidPC
TWAIN – Technology Without An Important Name

— U —
UART – Universal Asynchronous Receiver/Transmitter
USB – Universal Serial Bus
UTP – Unshieled Twisted Pair

— V —
VCD – Video CD
VPN – Virtual Private Network

— W —
WAN – Wide Area Network
WTB – Want to Buy
WYSIWYG – What You See Is What You Get

— X —
XGA – Extended Graphics Array
XFX – XFX Graphics, a Division of Pine
XMS – Extended Memory Specification
XT – Extended Technology

One analogy to describe this process might be to visualize a group of people sitting at a table. Each person at the table can both talk and listen to any other person at the table. These people are each trying to get a complete copy of a book. Person A announces that he has pages 1-10, 23, 42-50, and 75. Persons C, D, and E are each missing some of those pages that A has, and so they coordinate such that A gives them each copies of the pages he has that they are missing. Person B then announces that she has pages 11-22, 31-37, and 63-70. Persons A, D, and E tell B they would like some of her pages, so she gives them copies of the pages that she has. The process continues around the table until everyone has announced what they have (and hence what they are missing.) The people at the table coordinate to swap parts of this book until everyone has everything. There is also another person at the table, who we’ll call ‘S’. This person has a complete copy of the book, and so doesn’t need anything sent to him. He responds with pages that no one else in the group has. At first, when everyone has just arrived, they all must talk to him to get their first set of pages. However, the people are smart enough to not all get the same pages from him. After a short while they all have most of the book amongst themselves, even if no one person has the whole thing. In this manner, this one person can share a book that he has with many other people, without having to give a full copy to everyone that’s interested. He can instead give out different parts to different people, and they will be able to share it amongst themselves. This person who we’ve referred to as ‘S’ is called a seed in the terminology of BitTorrent.

How does BitTorrent compare to other forms of file transfer?
The most common method by which files are transferred on the Internet is the client-server model. A central server sends the entire file to each client that requests it — this is how both http and ftp work. The clients only speak to the server, and never to each other. The main advantages of this method are that it’s simple to set up, and the files are usually always available since the servers tend to be dedicated to the task of serving, and are always on and connected to the Internet. However, this model has a significant problem with files that are large or very popular, or both. Namely, it takes a great deal of bandwidth and server resources to distribute such a file, since the server must transmit the entire file to each client. Perhaps you may have tried to download a demo of a new game just released, or CD images of a new Linux distribution, and found that all the servers report “too many users,” or there is a long queue that you have to wait through. The concept of mirrors partially addresses this shortcoming by distributing the load across multiple servers. But it requires a lot of coordination and effort to set up an efficient network of mirrors, and it’s usually only feasible for the busiest of sites.

Another method of transferring files has become popular recently: the peer-to-peer network, systems such as Kazaa, eDonkey, Gnutella, Direct Connect, etc. In most of these networks, ordinary Internet users trade files by directly connecting one-to-one. The advantage here is that files can be shared without having access to a proper server, and because of this there is little accountability for the contents of the files. Hence, these networks tend to be very popular for illicit files such as music, movies, pirated software, etc. Typically, a downloader receives a file from a single source, however the newest version of some clients allow downloading a single file from multiple sources for higher speeds. The problem discussed above of popular downloads is somewhat mitigated, because there’s a greater chance that a popular file will be offered by a number of peers. The breadth of files available tends to be fairly good, though download speeds for obscure files tend to be low. Another common problem sometimes associated with these systems is the significant protocol overhead for passing search queries amongst the peers, and the number of peers that one can reach is often limited as a result. Partially downloaded files are usually not available to other peers, although some newer clients may offer this functionality. Availability is generally dependent on the goodwill of the users, to the extent that some of these networks have tried to enforce rules or restrictions regarding send/receive ratios.

Use of the Usenet binary newsgroups is yet another method of file distribution, one that is substantially different from the other methods. Files transferred over Usenet are often subject to miniscule windows of opportunity. Typical retention time of binary news servers are often as low as 24 hours, and having a posted file available for a week is considered a long time. However, the Usenet model is relatively efficient, in that the messages are passed around a large web of peers from one news server to another, and finally fanned out to the end user from there. Often the end user connects to a server provided by his or her ISP, resulting in further bandwidth savings. Usenet is also one of the more anonymous forms of file sharing, and it too is often used for illicit files of almost any nature. Due to the nature of NNTP, a file’s popularity has little to do with its availability and hence downloads from Usenet tend to be quite fast regardless of content. The downsides of this method include a baroque set of rules and procedures, and requires a certain amount of effort and understanding from the user. Patience is often required to get a complete file due to the nature of splitting big files into a huge number of smaller posts. Finally, access to Usenet often must be purchased due to the extremely high volume of messages in the binary groups.

BitTorrent is closest to Usenet, in my opinion. It is best suited to newer files, of which a number of people have interest in. Obscure or older files tend to not be available. Perhaps as the software matures a more suitable means of keeping torrents seeded will emerge, but currently the client is quite resource-intensive, making it cumbersome to share a number of files. BitTorrent also deals well with files that are in high demand, especially compared to the other methods.

Where can I download the BitTorrent program?
There are several choices here, because unlike some peer to peer applications (such as Kazaa), the BitTorrent implementation is open source. This means that programmers are free to take the source code to the program and modify it, if they feel there is something they’d like to change. Here are the various clients of which I am aware:

azureus: ( my no 1 )

http://azureus.sourceforge.net/

bittorrent++:

http://sourceforge.net/projects/btplusplus/

simplebit:

http://sourceforge.net/projects/simplebt/

bittorrent:

http://www.bittorrent.com/

What do all these words mean? (seeding, uploading, share rating, etc.)

Here is a brief list of words associated with BitTorrent and their meanings.

torrent:

Usually this refers to the small metadata file you receive from the web server (the one that ends in .torrent.) Metadata here means that the file contains information about the data you want to download, not the data itself. This is what is sent to your computer when you click on a download link on a website. You can also save the torrent file to your local system, and then click on it to open the BitTorrent download. This is useful if you want to be able to re-open the torrent later on without having to find the link again.
In some uses, it can also refer to everything associated with a certain file available with BitTorrent. For example, someone might say “I downloaded that torrent” or “that server has a lot of good torrents”, meaning there are lots of good files available via BitTorrent on that server.

peer:

A peer is another computer on the internet that you connect to and transfer data. Generally a peer does not have the complete file, otherwise it would be called a seed. Some people also refer to peers as leeches, to distinguish them from those generous folks who have completed their download and continue to leave the client running and act as a seed.

seed:

A computer that has a complete copy of a certain torrent. Once your client finishes downloading, it will remain open until you click the Finish button (or otherwise close it.) This is known as being a seed or seeding. You can also start a BT client with a complete file, and once BT has checked the file it will connect and seed the file to others. Generally, it’s considered good manners to continue seeding a file after you have finished downloading, to help out others. Also, when a new torrent is posted to a tracker, someone must seed it in order for it to be available to others. Remember, the tracker doesn’t know anything of the actual contents of a file, so it’s important to follow through and seed a file if you upload the torrent to a tracker.

reseed:

When there are zero seeds for a given torrent (and not enough peers to have a distributed copy), then eventually all the peers will get stuck with an incomplete file, since no one in the swarm has the missing pieces. When this happens, someone with a complete file (a seed) must connect to the swarm so that those missing pieces can be transferred. This is called reseeding. Usually a request for a reseed comes with an implicit promise that the requester will leave his or her client open for some time period after finishing (to add longevity to the torrent) in return for the kind soul reseeding the file.

swarm:

The group of machines that are collectively connected for a particular file. For example, if you start a BitTorrent client and it tells you that you’re connected to 10 peers and 3 seeds, then the swarm consists of you and those 13 other people.
tracker
A server on the Internet that acts to coordinate the action of BitTorrent clients. When you open a torrent, your machine contacts the tracker and asks for a list of peers to contact. Periodically throughout the transfer, your machine will check in with the tracker, telling it how much you’ve downloaded and uploaded, how much you have left before finishing, and the state you’re in (starting, finished download, stopping.) If a tracker is down and you try to open a torrent, you will be unable to connect. If a tracker goes down during a torrent (i.e., you have already connected at some point and are already talking to peers), you will be able to continue transferring with those peers, but no new peers will be able to contact you. Often tracker errors are temporary, so the best thing to do is just wait and leave the client open to continue trying.

downloading:

Receiving data FROM another computer.

uploading:

Sending data TO another computer.

share rating:

If you are using the experimental client with the stats-patch, you will see a share rating displayed on the GUI panel. This is simply the ratio of your amount uploaded divided by your amount downloaded. The amounts used are for the current session only, not over the history of the file. If you achieve a share ratio of 1.0, that would mean you’ve uploaded as much as you’ve downloaded. The higher the number, the more you have contributed. If you see a share ratio of “oo”, this means infinity, which will happen if you open a BT client with a complete file (i.e., you seed the file.) In this case you download nothing since you have the full file, and so anything you send will cause the ratio to reach infinity. Note: The share rating is just a number that is displayed for your convenience. It does not directly affect any aspect of the client at all. In general, out of courtesy to others you should strive to keep this ratio as high as possible, of course.

distributed copies:

In some versions of the client, you will see the text “Connected to n seeds; also seeing n.nnn distributed copies.” A seed is a machine with the complete file. However, the swarm can collectively have a complete copy (or copies) of the file, and that is what this is telling you. Referring again to the “people at a table” analogy, consider the case where the book has 10 pages, and person A has pp.1-5 and B has pp.6-10. Collectively, A and B have a complete copy of the book, even though no one person has the whole thing. In other words, even if there are no seeds, as long as there is at least one distributed copy of the file everyone can eventually get a complete file. Meditate on this, the Zen of BitTorrent, grasshopper.

choked:

This is a term used in the description of the BitTorrent protocol. It refers to the state of an uploader, i.e. the thread that sends data to another peer. When a connection is choked, it means that the transmitter doesn’t currently want to send anything on that link. A BT client signals that it’s choked to other clients for a number of reasons, but the most common is that by default a client will only maintain –max_uploads active simultaneous uploads, the rest will be marked choked. (The default value is 4 and this is the same setting that experimental client GUI lets you adjust.) A connection can also be choked for other reasons, for example a peer downloading from a seed will mark his connection as choked since the seed is not interested in receiving anything. Note that since each connection is bidirectional and symmetrical, there are two choked flags for each connection, one for each Tx endpoint.

interested:

Another term used in the protocol specification. This is the corollary to the choked flag, in that interested refers to the state of a downloader with respect to a connection. A downloader is marked as interested if the other end of the link has any pieces that the client wants, otherwise the connection is marked as not interested.

snubbed:

If the client has not received anything after a certain period (default: 60 seconds), it marks a connection as snubbed, in that the peer on the other end has chosen not to send in a while. See the definition of choked for reasons why an uploader might mark a connection as choked. The real function of keeping track of this variable is to improve download speeds. Occasionally the client will find itself in a state where even though it is connected to many peers, it is choked by all of them. The client uses the snubbed flag in an attempt to prevent this situation. It notes that a peer with whom it would like to trade pieces with has not sent anything in a while, and rather than leaving it up to the optimistic choking to eventuall select that peer, it instead reserves one of its upload slots for sending to that peer. (Reference)

optimistic unchoking:

Periodically, the client shakes up the list of uploaders and tries sending on different connections that were previously choked, and choking the connections it was just using. You can observe this action every 10 or 20 seconds or so, by watching the “Advanced” panel of one of the experimental clients.

XP uses the C:\Program Files directory as the default base directory into which new programs are installed. However, you can change the default installation drive and/ or directory by using a Registry hack.

Run the Registry Editor (regedit)and go to

HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion

Look for the value named ProgramFilesDir. by default,this value will be C:\Program Files. Edit the value to any valid drive or folder and XP will use that new location as the default installation directory for new programs.

Tip: Middleclick/MouseWheelClick on a Bookmark on your Personal Toolbar will open it up in a New Tab

Tip: MiddleClick/MouseWheel Click on a folder will open all the bookmarks in the folder in a new Tab(s)

Tip: holding down the Shift or Ctrl key when you RightClick to “View Image” or “View Backround Image”will open the image in a New Tab or New Window.

Tip: Unused menus or menu Items can be hidden by using the customizing your userChrome.css stylesheet

Tip: MiddleClick/MouseWheel Click on a Tab will close that Tab.

Tip: MiddleClick/MouseWheel Click on a History item will open the page in a new Tab

Tip: MiddleClick/MouseWheel Click on the Back and Forward buttons will open the last/next page in a new Tab

Tip: MiddleClick/MouseWheel Click on the Home button will open your homepage in a new Tab(s)

Tip: MiddleClick/MouseWheel Click on the Throbber (the ‘busy’ icon at the top-right) will open the Firefox homepage in a new Tab

Tip: For those without middle mouse buttons or mousewheels, ctrl-click will also open new tabs for links, bookmarks, bookmark folders, history items, and toolbar buttons

Tip: Ctrl+TAB you can navigate in the tabs to the right

Tip: Ctrl+Shift+Tab you can navigate in the tabs to the left

Tip: Many Laptops mimic the MiddleClick/MouseWheelClick function if you click both right/left pads at the same time.

Tip: Set mutliple Home pages : Tools—->Options—>General and seperate each page with the pipe | symbol
(eg) h**p://forums.mozillazine.org/|h**p://www.google.com

Tip: Clear your Download history to make the download manager more responsive : Tools—->Options—>Privacy

Tip: Rearrange add/remove Icons on Toolbars: View—>ToolBars—>Customize….

Tip: Drag any link to the Download Manager Window to add & download the link

Tip: Pressing ctrl+enter will add h**p://www. before and .com after the text in the toolbar and load the resulting url. Similarly, shift+enter will add h**p://www. and .net, and ctrl+shift+enter will add h**p://www. and .org

Tip: You can work offline like in IE by clicking File>Work Offline. This means that you can browse your previously visited pages even when you’re offline.

Tip: If you wish to remove an item from your Address Bar Drop down menu, Highlight it WITHOUT CLICKING and use Shift+Delete

Tip: A bookmarks’s position Dragged & Dropped (ie. change position in a Folder or move from one folder to another or move to another position on the toolbar) by highlighting it & clicking on it (WITHOUT LETTING GO) and Dragging it to your desired position

Tip: A Folder can be move the same way as above tip but u MUST hold down the SHIFT key while Dragging

Tip: Former/current users of IE who are accustomed to copying items from “Temporary Internet Files” folder (FireFox calls it “Cache” ) can achieve the same results by Tools—>Page Info and then select the “Media” Tab, then Highlight the item u want to download and clicking “Save As…”

Tip: If u accidentally delete a bookmark and want to recover it, if it is not already open then, open the “Bookmarks Manager” (Bookmarks—>Manage Bookmarks) and either use Ctrl+Z or Edit—>Undo (in The Bookmarks Manager)

Tip: DoubleClicking a file entry in the Downloads Manager will open/launch the file (provided u haven’t moved it yet)

Tip: You can also directly download anything from a page by drag and dropping it onto the ‘download’ icon in your toolbar (provided you put it there in ‘right-click > customize’)

Tip: You can bookmark the current page by dragging the icon from the location bar to your Bookmarks folder. You can also drag it to the desktop to make an icon for that page

Tip: Of course, you can also do what the last tip said in the other direction: drag a text file, a link, a picture, etcetera… from your folders or your desktop to Firefox and it will open in Firefox

Tip: You can save all open tabs in a bookmark folder. Ctl-D, select the “bookmark all tabs in a folder” select or create a folder.

Tip: To stop animated gifs from moving, press the ESC key.

Tip: Instead of clicking the Back or Forward buttons, hold down the Shift key and turn the scroll wheel to back or forward

Tip: you can give “keywords” to your bookmarks by right-clicking the bookmark and then Properties. If you put a string in the keyword field now you can type that keyword in the address bar and it will go to that bookmark. For example, if I have a bookmark for the firefox website, I might give it the keyword “ff”. Now, when I type “ff” in the address bar, it goes to the firefox site. I find it is often faster than going through your bookmarks to find it

Tip: Ctrl and a number key will go to the tab indicated by the number. (e.g. Ctrl+3 will go to the third tab from the left)

Tip: CTRL+F5 refreshes the page without accessign the file cache

Firefox Mouse Tips

Middle Click
Note: Two-button mouse

For those without middle mouse buttons or mousewheels, ctrl-click will also open new tabs for links, bookmarks, bookmark folders, history items, and toolbar buttons.

Many Laptops mimic the MiddleClick/MouseWheelClick function if you click both right/left pads at the same time.

Clicking both mouse buttons at the same time also mimics the MiddleClick/MouseWheelClick function.

Tabs

MiddleClick/MouseWheel Click on a Tab will close that Tab.

Personal Toolbar

Middleclick/MouseWheelClick on a Bookmark on your Personal Toolbar will open it up in a New Tab

Folders

MiddleClick/MouseWheel Click on a folder will open all the bookmarks in the folder in a new Tab(s)

History

MiddleClick/MouseWheel Click on a History item will open the page in a new Tab.

Back and Forward buttons

MiddleClick/MouseWheel Click on the Back and Forward buttons will open the last/next page in a new Tab.

Home button

MiddleClick/MouseWheel Click on the Home button will open your homepage in a new Tab(s).

Links

MiddleClick/MouseWheel Click on a link will open that link in a new tab.

Throbber

MiddleClick/MouseWheel Click on the Throbber (the ‘busy’ icon at the top-right) will open the Firefox homepage in a new Tab.

Images

Middleclick/MouseWheelClick on “View Image” or “View Background Image” will open the image in a New Tab.

Double Click
Download Manager

DoubleClicking a file entry in the Downloads Manager will open/launch the file (provided you haven’t moved it yet)

Tab Bar

Double Clicking empty space on the Tab Bar will open a ‘New Tab’

Right Click
Customize Toolbar

You can adjust your toolbars to your liking. Right click on any toolbar, and select ‘Customize’. While this dialogue is up, you can move buttons around on your toolbars by click-and-drag to the new location. The window that pops up when you do this is a holding area for unused icons. You can drag any item from it onto your toolbars to have it made available, and you can drag any icon from your toolbars onto this box to hide that icon completely.

Tip: Some toolbar items, such as the Location bar, will expand to take up all available space.

Keyword Bookmark

Right clicking in a search box (such as the ‘search mozillazine, powered by google’, on the left of this page) and selecting ‘add a keyword for this search’ lets you make an interactive keyword bookmark.

Here is how it works:

Give it a name, such as ‘Mozillazine search’
now, assign a keyword to it, such as ‘moz’
click ‘ok’

From now on, you can search mozillazine (or any other search box you used for this) from your address bar like this:

Enter ‘moz search topic’ in your address bar and click Go!

Drag’n Drop
Moving bookmarks and folders

You can change a bookmark’s position in a folder or move it from one folder to another or move it to another position on the toolbar by highlighting it & clicking on it (WITHOUT LETTING GO) and dragging it to your desired position.

A folder can be moved the same way as above tip but u MUST hold down the SHIFT key while dragging.

Icons

You can bookmark the current page by dragging the icon from the location bar to your Bookmarks folder. You can also drag it to the desktop to make an icon for that page.

Drag a text file, a link, a picture, etcetera… from your folders or your desktop to Firefox and it will open in Firefox!

Links

“Click-and-drag” a bookmark to the main content windown (which is the biggest on the firefox userinterface),so you can open it in a new tab !

Dragging a link onto a new tab will open the link in the new tab.

Downloading links

Drag any link to the Download Manager Window to add & download the link.

You can also directly download anything from a page by drag and dropping it onto the ‘download’ icon in your toolbar (provided you put it there in ‘right-click > customize’)

Mouse and Keyboard
Images

Holding down the Shift or Ctrl key when you RightClick to “View Image” or “View Background Image” will open the image in a New Tab or New Window.

Selecting text

If you hold down the CTRL key and left click on part of a web page, that section of the page will be highlighted. If you right click on the selection and choose ‘View selection source’, the source code for that part of the page will be displayed.

To quickly highlight text, especially long text fields. Left-click once in the window where you want the selection to start; and then shift-click in the spot where you want the selection to end (selection range). *this is a lot easier than click-selection-dragging, especially where there is a lot of text to highlight.

What makes these tips special is that the information they provide usually cannot be found in C++ books or Web sites. For example, pointers to members are one of the most evasive, tricky, and bug-prone issues for even advanced users. Yet, they are a widely used C++ feature. Likewise, the discussion on STL terminology and iterator categories is another example of useful yet evasive information that isn’t readily available, unless you’re an STL expert.

The tips herein do not only explain how to write better code, but rather, they present the rationale behind the new language rules. Obviously, there are many other perennial good tips that C++ programmers can benefit from. However, I’m sure that this collection will provide you with many insights and guidelines for professional, efficient, and bug-free C++while teaching you some new coding and design techniques.

First Four: Guidelines for Better Coding Style

Under this category, I grouped tips that address frequently asked questions from C++ programmers of all levels of expertise. It’s surprising to discover how many experienced programmers are still unaware of the deprecation of the .h notation of standard header files, the proper usage of namespaces, and the rules regarding binding of references to temporary objects, for example. These issues and others will be discussed here. First, we start by explaining the difference between the deprecated <xxx.h> header names and the modern, standard-compliant <xxx> header-naming notation. Next, we explore a few dark corners of C++ whichdue to compilers’ limitations and the somewhat recondite nature of the associated language rulestend to confuse many programmers, e.g., the notion of comma-separated expressions and the rules of binding references to rvalues. Finally, we will learn how to invoke a function prior to a program’s startup.

Tip 1: <iostream.h> or <iostream>?

Many C++ programmers still use <iostream.h> instead of the newer, standard compliant <iostream> library. What are the differences between the two? First, the .h notation of standard header files was deprecated more than five years ago. Using deprecated features in new code is never a good idea. In terms of functionality, <iostream> contains a set of templatized I/O classes which support both narrow and wide characters, as opposed to <iostream.h> which only supports char-oriented streams. Third, the C++ standard specification of iostream’s interface was changed in many subtle aspects. Consequently, the interfaces and implementation of <iostream> differ from those of <iostream.h>. Finally, <iostream> components are declared in namespace std whereas <iostream.h> components are global.

Because of these substantial differences, you cannot mix the two libraries in one program. As a rule, use <iostream> unless you’re dealing with legacy code that is only compatible with <iostream.h>.

Tip 2: Binding a Reference to an Rvalue

Rvalues and lvalues are a fundamental concept of C++ programming. In essence, an rvalue is an expression that cannot appear on the left-hand side of an assignment expression. By contrast, an lvalue refers to an object (in its wider sense), or a chunk of memory, to which you can write a value. References can be bound to both rvalues and lvalues. However, due to the language’s restrictions regarding rvalues, you have to be aware of the restrictions on binding references to rvalues, too.

Binding a reference to an rvalue is allowed as long as the reference is bound to a const type. The rationale behind this rule is straightforward: you can’t change an rvalue, and only a reference to const ensures that the program doesn’t modify an rvalue through its reference. In the following example, the function f() takes a reference to const int:

void f(const int & i);
int main()
{
f(2); /* OK */
}

The program passes the rvalue 2 as an argument to f(). At runtime, C++ creates a temporary object of type int with the value 2 and binds it to the reference i. The temporary and its reference exist from the moment f() is invoked until it returns; they are destroyed immediately afterwards. Note that had we declared the reference i without the const qualifier, the function f() could have modified its argument, thereby causing undefined behavior. For this reason, you may only bind references to const objects.

The same rule applies to user-defined objects. You may bind a reference to a temporary object only if it’s const:

struct A{};
void f(const A& a);
int main()
{
f(A()); /* OK, binding a temporary A to a const reference*/
}

Tip 3: Comma-Separated Expressions

Comma-separated expressions were inherited from C. It’s likely that you use such expressions in for- and while-loops rather often. Yet, the language rules in this regard are far from being intuitive. First, let’s see what a comma separated expression is.

An expression may consist of one or more sub-expressions separated by commas. For example:

if(++x, –y, cin.good()) /*three expressions*/

The if condition contains three expressions separated by commas. C++ ensures that each of the expressions is evaluated and its side effects take place. However, the value of an entire comma-separated expression is only the result of the rightmost expression. Therefore, the if condition above evaluates as true only if cin.good() returns true. Here’s another example of a comma expression:

int j=10;
int i=0;
while( ++i, –j)
{
/*..repeat as long as j is not 0*/
}

Tip 4: Calling a Function Before Program’s Startup

Certain applications need to invoke startup functions that run before the main program starts. For example, polling, billing, and logger functions must be invoked before the actual program begins. The easiest way to achieve this is by calling these functions from a constructor of a global object. Because global objects are conceptually constructed before the program’s outset, these functions will run before main() starts. For example:

class Logger
{
public:
Logger()
{
activate_log();
}
};
Logger log; /*global instance*/

int main()
{
record * prec=read_log();
//.. application code
}

The global object log is constructed before main() starts. During its construction, log invokes the function activate_log(). Thus, when main() starts, it can read data from the log file.

Five to Eight: Memory Management
Undoubtedly, memory management is one of the most intricate and bug-prone issues in C++ programming. The power of accessing raw memory directly, the ability to allocate storage dynamically, and the utmost efficiency of C++ dictate very strict rules that you must follow in order to avoid memory-related bugs and runtime crashes.
devx/cplus/815/16328: 336×280

Pointers are the primary means of accessing memory. C++ has two major categories of them: pointers to data and pointers to function. The second category is further divided into two subcategories: ordinary function pointers and pointers to members. In the following tips, we will explore these issues in depth and learn some technique to streamline the use of pointers while hiding their unwieldy syntax.

Pointers to functions are probably one of the least readable syntactic constructs of C++. The only less readable construct seems to be pointers to members. The first tip will teach you how to improve the readability of ordinary pointers to functions. This serves as the prerequisite for dealing with C++ pointers to members.

Next, we learn how to avoid memory fragmentation and its woeful consequences. Finally, we discuss the proper use of delete and delete[] operatorsstill, a fertile source of bugs and misconceptions.

Tip 5: Hiding the Cumbersome Syntax of Pointers to Functions

Can you tell what the following declaration means?

void (*p[10]) (void (*)());

p is an “array of 10 pointers to a function returning void and taking a pointer to another function that returns void and takes no arguments.” The cumbersome syntax is nearly indecipherable, isn’t it? You can simplify this declaration considerably by using typedefs. First, declare a typedef for “pointer to a function returning void and taking no arguments” as follows:

typedef void (*pfv)();

Next, declare another typedef for “pointer to a function returning void and taking a pfv”:

typedef void (*pf_taking_pfv) (pfv);

Now declaring an array of 10 such pointers is a breeze:

pf_taking_pfv p[10]; /*equivalent to
void (*p[10]) (void (*)()); but much more readable*/

Tip 6: All About Pointers to Members

A class can have two general categories of members: function members and data members. Likewise, there are two categories of pointers to members: pointers to member functions and pointers to data members. The latter are less common because in general, classes do not have public data members. However, when using legacy C code that contains structs or classes that happen to have public data members, pointers to data members are useful.

Pointers to members are one of the most intricate syntactic constructs in C++, and yet, they are a very powerful feature too. They enable you to invoke a member function of an object without having to know the name of that function. This is very handy implementing callbacks. Similarly, you can use a pointer to data member to examine and alter the value of a data member without knowing its name.

Pointers to Data Members

Although the syntax of pointers to members may seem a bit confusing at first, it’s consistent and resembles the form of ordinary pointers, with the addition of the class name followed by the operator :: before the asterisk. For example, if an ordinary pointer to int looks as follows:

int * pi;

You define a pointer to an int member of class A as follows:

int A::*pmi; /* pmi is a pointer to an int member of A*/

You initialize a pointer to member like this:

class A
{
public:
int num;
int x;
};
int A::*pmi = & A::num; /* 1 */

The statement numbered 1 declares a pointer to an int member of class A and initializes it with the address of the member num. Using pmi and the built-in operator .* you can examine and modify the value of num in any object of class A:

A a1, a2;
int n=a1.*pmi; /* copy a1.num to n */
a1.*pmi=5; /* assign the value 5 to a1.num */
a2.*pmi=6; /* assign the value 6 to a2.num */

If you have a pointer to A, you need to use the built-in operator ->* instead:

A * pa=new A;
int n=pa->*pmi;
pa->*pmi=5;

Pointers To Member Functions

These consist of the member function’s return type, the class name followed by ::, the pointer’s name, and the function’s parameter list. For example, a pointer to a member function of class A that returns an int and takes no arguments is defined as follows (note that both pairs of parentheses are mandatory):

class A
{
public:
int func ();
};

int (A::*pmf) ();

In other words, pmf is a pointer to a member function of class A that returns int and takes no arguments. In fact, a pointer to a member functions looks as an ordinary pointer to function, except that it also contains the class’s name immediately followed by the :: operator. You can invoke the member function to which pmf points using operator .*:

pmf=&A::func;
A a;
(a.*pmf)(); /* invoke a.func() */

If you have a pointer to an object, you use the operator ->* instead:

A *pa=&a;
(pa->*pmf)(); /*calls pa->func() */

Pointers to member functions respect polymorphism. Thus, if you call a virtual member function through such a pointer, the call will be resolved dynamically. Note, however, that you can’t take the address of a class’s constructor and destructor.

Tip 7: Avoiding Memory Fragmentation

Often, applications that are free from memory leaks but frequently allocate and deallocate dynamic memory show gradual performance degradation if they are kept running for long periods. Finally, they crash. Why is this? Recurrent allocation and deallocation of dynamic memory causes heap fragmentation, especially if the application allocates small memory chunks. A fragmented heap might have many free blocks, but these blocks are small and non-contiguous. To demonstrate this, look at the following scheme that represents the system’s heap. Zeros indicate free memory blocks and ones indicate memory blocks that are in use:

100101010000101010110

The above heap is highly fragmented. Allocating a memory block that contains five units (i.e., five zeros) will fail, although the systems has 12 free units in total. This is because the free memory isn’t contiguous. On the other hand, the following heap has less free memory but it’s not fragmented:

1111111111000000

What can you do to avoid heap fragmentation? First, use dynamic memory as little as possible. In most cases, you can use static or automatic storage or use STL containers. Secondly, try to allocate and de-allocate large chunks rather than small ones. For example, instead of allocating a single object, allocate an array of objects at once. As a last resort, use a custom memory pool.

Tip 8: Don’t Confuse Delete with Delete []

There’s a common myth among programmers that it’s OK to use delete instead of delete [] to release arrays built-in types. For example,

int *p=new int[10];
delete p; /*bad; should be: delete[] p*/

This is totally wrong. The C++ standard specifically says that using delete to release dynamically allocated arrays of any type yields undefined behavior. The fact that on some platforms, applications that use delete instead of delete [] don’t crash can be attributed to sheer luck: Visual C++, for example, implements both delete[] and delete for built-in types by calling free(). However, there is no guarantee that future releases of Visual C++ will adhere to this convention. Furthermore, there’s no guarantees that this code will work on other compilers. To conclude, using delete instead of delete[] and vice versa is hazardous and should be avoided.

Nine to 11: Performance Enhancements

The following tips list three simple—yet rather unfamiliar—techniques to improve your program’s performance, without sacrificing its readability or entailing design modifications. For example, programmers often don’t know that simply by reordering data members in a class, they can significantly reduce its size. This optimization can boost performance especially if your application uses arrays of such objects. We will also learn the difference between postfix and prefix operatorsan issue of special importance when dealing with overloaded operators. Finally, we will learn a few techniques to eliminate the creation of temporary objects.
Featured Resources for
Developing Intelligent Connections from the
Avaya DeveloperConnection Center
ARTICLE
Pushing the Limits: Avaya IP Telephones Equip Developers with Web and Push APIs
Learn how the Avaya APIs work and get started.

DOWNLOAD
Avaya Dialog Designer Software
Open-standards based IDE for voice self-service applications.

WHITEPAPER
Next Generation Business Communications Applications
Learn how communications will be molded, injected, and programmed into business processes, thanks to Web Services/SOA and SIP.

Tip 9: Optimizing Class Member Alignment

The size of a class can be changed simply by playing with the order of its members’ declaration:

struct A
{
bool a;
int b;
bool c;
}; /*sizeof (A) == 12*/

On my machine, sizeof (A) equals 12. This result might seem surprising because the total size of A’s members is only 6 bytes: 1+4+1 bytes. Where did the remaining 6 bytes come from? The compiler inserted 3 padding bytes after each bool member to make it align on a four-byte boundary. You can reduce A’s size by reorganizing its data members as follows:

struct B
{
bool a;
bool c;
int b;
}; // sizeof (B) == 8

This time, the compiler inserted only 2 padding bytes after the member c. Because b occupies four bytes, it naturally aligns on a word boundary without necessitating additional padding bytes.

Tip 10: Differences between Postfix and Prefix Operators

The built-in ++ and operators can appear on both sides of their operand:

int n=0;
++n; /*prefix*/
n++; /*postfix*/

You probably know that a prefix operator first changes its operand before taking its value. For example:

int n=0, m=0;
n = ++m; /*first increment m, then assign its value to n*/
cout << n << m; /* display 1 1*/

In this example, n equals 1 after the assignment because the increment operation took place before m’s value was taken and assigned to n. By contrast,

int n=0, m=0;
n = m++; /*first assign m’s value to n, then increment m*/
cout << n << m; /*display 0 1*/

In this example, n equals 0 after the assignment because the increment operation took place after m’s original value was taken and assigned to n.

To understand the difference between postfix and prefix operators better, examine the disassembly code generated for these operations. Even if you’re not familiar with assembly languages, you can immediately see the difference between the two; simply notice where the inc (increment) assembly directive appears:

/*disassembly of the expression: m=n++;*/
mov ecx, [ebp-0x04] /*store n’s value in ecx register*/
mov [ebp-0x08], ecx /*assign value in ecx to m*/
inc dword ptr [ebp-0x04] /*increment n*/

/*disassembly of the expression: m=++n;*/
inc dword ptr [ebp-0x04] /*increment n;*/
mov eax, [ebp-0x04] /*store n’s value in eax register*/
mov [ebp-0x08], eax /*assign value in eax to m*/

Tip 11: Eliminating Temporary Objects

C++ creates temporary objects “behind your back” in several contexts. The overhead of a temporary can be significant because both its constructor and destructor are invoked. You can prevent the creation of a temporary object in most cases, though. In the following example, a temporary is created:

Complex x, y, z;
x=y+z; /* temporary created */

The expression y+z; results in a temporary object of type Complex that stores the result of the addition. The temporary is then assigned to x and destroyed subsequently. The generation of the temporary object can be avoided in two ways:

Complex y,z;
Complex x=y+z; /* initialization instead of assignment */

In the example above, the result of adding x and z is constructed directly into the object x, thereby eliminating the intermediary temporary. Alternatively, you can use += instead of + to get the same effect:

/* instead of x = y+z; */
x=y;
x+=z;

Although the += version is less elegant, it costs only two member function calls: assignment operator and operator +=. In contrast, the use of + results in three member function calls: a constructor call for the temporary, a copy constructor call for x, and a destructor call for the temporary.

12 and 13: Object-oriented Design

Although C++ supports several useful programming paradigms such as procedural programming, functional programming, and generic programming, object-oriented programming is unquestionably the most widely used and important paradigm. The following two tips provide guidelines for better object-oriented design and implementation. First, I will explain the importance of virtual destructors in class hierarchies. The next tip in this category shows how to deal with nested classes that are declared as friends of the enclosing class.

Tip 12: Why Inheriting from a Class That Has No Virtual Destructor is Dangerous
Classes with a non-virtual destructor aren’t meant to serve as base classes (such classes are usually known as “concrete classes”). std::string, std::complex, and std::vector are concrete classes. Why is inheriting from such classes not recommended? When you use public inheritance, you create an is-a relationship between the base class and its derived classes. Consequently, pointers and references to base can actually point to a derived object. Because the destructor isn’t virtual, C++ will not call the entire destructor chain when you delete such an object. For example:

class A
{
public:
~A() // non virtual
{
// …
}
};

class B: public A /* bad; A has a non virtual dtor*/
{
public:
~B()
{
// …
}
};

int main()
{
A * p = new B; /*seemingly OK*/
delete p; /*trouble, B’s dtor not called*/
}

The result of failing to invoke an object’s destructor is undefined. Therefore, you shouldn’t use publicly inherit from such classes. In particular, don’t derive from STL containers and std::string, as tempting as it may seem.

Tip 13: Declaring Nested Classes as Friends of Their Enclosing Class

When you declare a nested class as a friend of its containing class, place the friend declaration after the declaration of the nested class, not before it:

class A
{
private:
int i;
public:
class B /*nested class declared first*/
{
public:
B(A & a) { a.i=0;}; /*access A’s private member*/
};
friend class B;/*friend declaration at the right place*/
};

If you place the friend declaration before the nested class’s declaration, the compiler will discard the declaration since the friend class hasn’t been seen yet.

14 to 20: STL and Generic Programming
The Standard Template Library (STL) has revolutionized the way C++ programmers write code. It brings code reuse to new levels of productivity and it saves huge amounts of time that would have otherwise been spent on reinventing wheels. Yet, it’s a full-blown framework, with a peculiar jargon and intricate rules that you have to master in order to learn how to use it effectively. To shed some light on certain aspects of STL, I decided to include no less than six tips under this category.

Naturally, the first tip describes the basic constituents of STL and some of its key terms.

The next tip deals with template definitions. As you probably know, templates are the building bricks of STL containers and algorithms. The following three tips describe techniques of using the std::vector container—the most widely-used STL container. We will learn how to properly store pointers to objects in a vector and how to avoid common pitfalls; we will see how to treat a vector object as if it were a built-in array. The fifth tip in this category will show you how to use vectors to imitate a multidimensional array. Finally, the closing tip in this category teaches a very important lesson about the interaction of std::auto_ptr and STL.

Tip 14: Useful STL Terminology
Here are some key terms that you may find useful when reading Standard Template Library (STL) literature and documentation.

Container
A container is an object that stores objects as its elements. Normally, it’s implemented as a class template that has member functions for traversing, storing and removing elements. Examples of container classes are std::list and std::vector.

Genericity
The quality of being generic, or type-independent. The above definition of the term container is too loose because it may apply to strings, arrays and structs, which also store objects. However, a real container isn’t limited to a specific data type or a set of types. Rather, it can store any built-in and user-defined type. Such a container is said to be generic. Note that a string can only contain characters. Genericity is perhaps the most important characteristic of STL. The third tip presents the standard base classes for function objects. Since function objects are one of the constituents of generic programming, adhering to standard conventions in their design and implementation will save you a lot of difficulties.

Algorithm
A set of operations applied to a sequence of objects. Examples of algorithms are std::sort(), std::copy(), and std::remove(). STL algorithms are implemented as function templates taking iterators.

Adaptor
An adaptor is a special object that can be plugged to an exiting class or function to change its behavior. For example, by plugging a special adaptor to the std::sort() algorithm, you can control whether the sorting order is descending or ascending. STL defines several kinds of sequence adaptors, which transform a container to a different container with a more restricted interface. A stack, for instance, is often formed from queue and an adaptor that provides the necessary push() and pop() operations.

Big Oh Notation
A special notation used in performance measurements of algorithms. The STL specification imposes minimum performance limits on the operations of its algorithms and container operations. An implementation may offer better performance but not worse. The Big Oh notation enables you to evaluate the efficiency of algorithms and containers for a given operation and data structure. An algorithm such as std::find(), which traverses every element is a sequence (in the worst case scenario) has the following notation:

T(n) = O(n). /* linear complexity */

Iterator
An iterator is an object that functions as a generic pointer. Iterators are used for traversing, adding and removing container elements. STL defines five major categories of iterators:

input iterators and output iterators
forward iterators
bidirectional iterators
random access iterators

Note that this list doesn’t represent inheritance relationships; it merely describes the iterator categories and their interfaces. Each lower category is a superset of the category above it. For instance, a bidirectional iterator provides all the functionality of a forward iterators plus additional functionality. Here is a brief summary of the functionality and interfaces for these categories:

Input iterators allow an algorithm to advance the iterator and offer read-only access to an element.

Output iterators allow an algorithm to advance the iterator and offer write-only access to an element.

Forward iterators support both read and write access, but traversal is permitted only in one direction.

Bidirectional iterators allow the user to traverse the sequence in both directions.

Random access iterators support random jumps and “pointer arithmetic” operations, for example:

string::iterator it = s.begin();
char c = *(it+5); /* assign sixth char to c*/

Tip 15: The Location of Template Definitions
Normally, you declare functions and classes in a .h file and place their definition in a separate .cpp file. With templates, this practice isn’t really useful because the compiler must see the actual definition (i.e., the body) of a template, not just its declaration, when it instantiates a template. Therefore, it’s best to place both the template’s declaration and definition in the same .h file. This is why all STL header files contain template definitions.

In the future, when compilers support the “export” keyword, it will be possible to use only the template’s declaration and leave the definition in a separate source file.

Tip 16: Standard Base Classes for Function Object
To simplify the process of writing function objects, the Standard Library provides two class templates that serve as base classes of user-defined function objects: std::unary_function and std::binary_function. Both are declared in the header . As the names suggest, unary_function serves as a base class of function objects taking one argument and binary_function serves as a base class of function objects taking two arguments. The definitions of these base classes are as follows:

template struct
unary_function
{
typedef Arg argument_type;
typedef Res result_type;
};
template
struct binary_function
{
typedef Arg first_argument_type;
typedef Arg2 second_argument_type;
typedef Res result_type;
};

These templates don’t provide any useful functionality. They merely ensure that arguments and return values of their derived function objects have uniform names. In the following example, the predicate is_vowel, which takes one argument, inherits from unary_function:

template
class is_vowel: public unary_function
{
public:
bool operator ()(T t) const
{
if ((t==’a')||(t==’e')||(t==’i')||(t==’o')||(t==’u'))
return true;
return false;
}
};

Tip 17: Storing Dynamically Allocated Objects in STL Containers
Suppose you need to store objects of different types in the same container. Usually, you do this by storing pointers to dynamically allocated objects. However, instead of using named pointers, insert the elements to the container as follows:

class Base {};
class Derived : public Base{};

std::vector v;
v.push_back(new Derived);
v.push_back(new Base);

This way you ensure that the stored objects can only be accessed through their container. Remember to delete the allocated objects as follows:

delete v[0];
delete v[1];

Tip 18: Treating a Vector as an Array
Suppose you have a vector of int and function that takes int *. To obtain the address of the internal array of the vector v and pass it to the function, use the expressions &v[0] or &*v.front(). For example:

void func(const int arr[], size_t length );
int main()
{
vector vi;
//.. fill vi
func(&vi[0], vi.size());
}

It’s safe to use &vi[0] and &*v.front() as the internal array’s address as long as you adhere to the following rules: First, func() shouldn’t access out-of-range array elements. Second, the elements inside the vector must be contiguous. Although the C++ Standard doesn’t guarantee that yet, I’m not aware of any implementation that doesn’t use contiguous memory for vectors. Furthermore, this loophole in the C++ Standard will be fixed soon.

Tip 19: Dynamic Multidimensional Arrays and Vectors
You can allocate multidimensional arrays manually, as in:

int (*ppi) [5]=new int[4][5]; /*parentheses required*/
/*fill array..*/
ppi[0][0] = 65;
ppi[0][1] = 66;
ppi[0][2] = 67;
//..
delete [] ppi;

However, this style is tedious and error prone. You must parenthesize ppi to ensure that the compiler parses the declaration correctly, and you must delete the allocated memory. Worse yet, you can easily bump into buffer overflows. Using a vector of vectors to simulate a multidimensional array is a significantly superior alternative:

#include
#include
using namespace std;
int main()
{
vector <vector > v; /*two dimensions*/
v.push_back(vector ()); /*create v[0]*/
v.push_back(vector ()); /*create v[1]*/
v[0].push_back(15); /*assign v[0][0]*/
v[1].push_back(16); /*assign v[1][0]*/
}

Because vector overloads operator [], you can use the [][] notation as if you were using a built-in two-dimensional array:

cout << v[0][0];
cout << v[1][0];

The main advantages of using a vector of vectors are two: vector automatically allocates memory as needed. Secondly, it takes care of deallocating memory so you don’t have to worry about potential memory leaks.

Tip 20: Why You Shouldn’t Store auto_ptr Objects in STL Containers
The C++ Standard says that an STL element must be “copy-constructible” and “assignable.” These fancy terms basically mean that for a given class, assigning and copying one object to another are well-behaved operations. In particular, the state of the original object isn’t changed when you copy it to the target object.

This is not the case with auto_ptr, though: copying or assigning one auto_ptr to another makes changes to the original in addition to the expected changes in the copy. To be more specific, the original object transfers ownership of the pointer to the target, thus making the pointer in the original null. Imagine what would happen if you did something like this:

std::vector <auto_ptr > vf;/*a vector of auto_ptr’s*/
// ..fill vf
int g()
{
std::auto_ptr temp=vf[0]; /*vf[0] becomes null*/
}

When temp is initialized, the pointer of vf[0] becomes null. Any attempt to use that element will cause a runtime crash. This situation is likely to occur whenever you copy an element from the container. Remember that even if your code doesn’t perform any explicit copy or assignment operations, many algorithms (std::swap(), std::random_shuffle() etc.) create a temporary copy of one or more container elements. Furthermore, certain member functions of the container create a temporary copy of one or more elements, thereby nullifying them. Any subsequent attempt to the container elements is therefore undefined.

Visual C++ users often say that they have never encountered any problems with using auto_ptr in STL containers. This is because the auto_ptr implementation of Visual C++ (all versions thereof) is outdated and relies on an obsolete specification. When the vendor decides to catch up with the current ANSI/ISO C++ Standard and change its Standard Library accordingly, code that uses auto_ptr in STL containers will manifest serious malfunctions.

To conclude, you shouldn’t use auto_ptr in STL containers. Use either bare pointers or other smart pointer classes instead of auto_ptr (such classes are available at www.Boost.org).

These optimizations are fairly easy to apply to existing code and in some cases can result in big speedups. Remember the all-important maxim though, the fastest code is code that isn’t called.
Use Initialization Lists

Always use initialization lists in constructors. For example, use

TMyClass::TMyClass(const TData &data) : m_Data(data)
{
}

rather than

TMyClass::TMyClass(const TData &data)
{
m_Data = data;
}

Without initialization lists, the variable’s default constructor is invoked behind-the-scenes prior to the class’s constructor, then its assignment operator is invoked. With initialization lists, only the copy constructor is invoked.
Optimize For Loops

Whereever possible, count down to zero rather than up to n. For example, use

for (i = n-1; i >= 0; –i)

rather than

for (i = 0; i < n; ++i)

The test is done every iteration and it’s faster to test against zero than anything else. Note also that

++i

is faster than

i++

when it appears in the third part of the for loop statement.
Use ‘int’

Always use the int data type instead of char or short wherever possible. int is always the native type for the machine.
Make Local Functions Static

Always declare local functions as static, e.g.,

static void foo()

This means they will not be visible to functions outside the .cpp file, and some C++ compilers can take advantage of this in their optimizations.
Optimize If Statements

Factor out jumps. For example, use

bar();
if (condition)
{
undoBar();
foo();
}

rather than

if (condition)
{
foo();
}
else
{
bar();
}

Use a profiler and good judgement to decide if undoing the bar() operation is faster than jumping.
Optimize Switch Statements

Put the most common cases first.
Avoid Expensive Operations

Addition is faster than multiplication and multiplication is faster than division. Factor out expensive operations whereever possible.
Initialize on Declaration

Whereever possible, initialize variables at the time they’re declared. For example,

TMyClass myClass = data;

is faster than

TMyClass myClass;
myClass = data;

Declaration then initialization invokes the object’s default constructor then its assignment operator. Initializing in the declaration invokes only its copy constructor.
Pass By Reference

Always try to pass classes by reference rather than by value. For example, use

void foo(TMyClass &myClass)

rather than

void foo(TMyClass myClass)

Delay Variable Declarations

Leave variable declarations right until the point when they’re needed. Remember that when a variable is declared its constructor is called. This is wasteful if the variable is not used in the current scope.
Use ‘op=’

Wherever possible, use ‘op=’ in favour of ‘op’. For example, use

myClass += value;

rather than

myClass = myClass + value;

The first version is better than the second because it avoids creating a temporary object.
Inline Small Functions

Small, performance critical functions should be inlined using the inline keyword, e.g.,

inline void foo()

This causes the compiler to duplicate the body of the function in the place it was called from. Inlining large functions can cause cache misses resulting in slower execution times.
Use Nameless Classes

Whereever possible, use nameless classes. For example,

foo(TMyClass(“abc”));

is faster than

TMyClass myClass(“abc”);
foo(myClass);

because, in the first case, the parameter and the class share memory.

here s the way to create : in cmd promt enter : attrib +s +h path of the filename

to get back the original file use : attrib -s -h path of the filename

enable super hidden files and folders by making some modifications in regkey

enter regedit in run and locate : Hkey_current_user->Software->Microsoft->Windows->Current Version->explorer->advanced
and change the value of ShowSuperHidden to 1 to enable and 0 to disable

======================================================================

Display or change file attributes. Find Filenames.

Syntax
ATTRIB [ + attribute | - attribute ] [pathname] [/S]

Key
+ : Turn an attribute ON
- : Clear an attribute OFF

pathname : Drive and/or filename e.g. C:\*.txt
/S : Search the pathname including all subfolders.

attributes:
H Hidden
S System
R Read-only
A Archive

If no attributes are specified attrib will return the current attribute settings. Used with just the /S option ATTRIB will quickly search for a particular filename.

Combining the Hidden and System attributes.

If a file has both the Hidden and System attributes set, you can clear both attributes only with a single ATTRIB command.

For example, to clear the Hidden and System attributes for the RECORD.TXT file, you would type:
ATTRIB -S -H RECORD.TXT

Using ATTRIB with groups of files

You can use wildcards (? and *) with the filename parameter to display or change the attributes for a group of files.

Remember that, if a file has the System or Hidden attribute set, you must clear that attribute before you can change any other attributes.

Changing the attributes for a directory

You can display or change the attributes for a directory. To use ATTRIB with a directory, you must explicitly specify the directory name; you cannot use wildcards to work with directories.

For example, to hide the directory C:\SECRET, you would type the following:

ATTRIB +H C:\SECRET

The following command would affect only files, not directories: ATTRIB +H C:*.*

Viewing archive attributes

The Archive attribute (A) is used to mark files that have changed since they were previously backed up. The (A) flag is automatically updated by Windows as the file is saved.

If the (A) flag is present – the file is new or has been changed since the last backup.

The MSBACKUP, RESTORE, and XCOPY commands use these Archive attributes, as do many (but not all) 3rd party backup solutions.

New attributes in Windows XP

In addition to A,H,R,S, the latest version of NTFS includes the following new attributes

E = Encrypted, C = Compressed, T = Temporary, O = Offline