Read the article
dr.p posted. However, bear in mind it's written with logical segments in mind. Some assemblers and compilers refer to these as 'sections' instead, to resolve the ambiguity.
For x86-based CPUs, memory is accessed with a combination of two registers. Exactly how this works depends on what mode the processor is in; this is either real address mode (or just real mode) or protected mode. There is also a virtual-8086 mode (or just V86) on 386 and higher processors, but this generally functions as real mode from the point of view of applications, so I won't discuss it here. Protected mode is further divided into 16-bit and 32-bit versions, but generally when people refer to protected mode, they're talking about 32-bit. Real mode is the default mode at boot (and the only available mode on pre-286 CPUs), while 32-bit protected mode is only available on 386 and higher CPUs.
Anyways, back to addressing. The first is the segment register, and the second is the offset. In real mode, the segment register simply stores a portion of the physical address. In particular, it stores the 'paragraph' (16-byte memory block) that the actual address starts at. Thus, if you have A000h in your segment register, and 00FFh in the offset register, the actual physical address is A00FFh. This is normally expressed with A000:00FF or some similar notation. One caveat with real mode is that multiple logical addresses map to the same physical address. For example, 9FF0:010F maps to the same address. To verify this, left-shift the segment by four bits, and add in the offset. The main point of segmented memory addressing is to allow a 16-bit CPU (or CPU in a 16-bit mode) to access more than 64k of memory. The 8086 had a 20-bit address bus, but with the 16 bit register size, it needed a pair of them to access the full address space. This is also where the 'high memory area' on later machines came in. Rather than wrap back to address 0 when an address exceeded FFFFFh, a portion of memory above the one-megabyte mark could be addressed. This was because the memory was still there, and by enabling the 21st address line (commonly called the A20 line), this wraparound did not occur. This enabled real-mode software to access just shy of an additional 64k of memory (64k minus 16, so 65520 bytes). To see how this worked, consider the address FFFF:FFFF. This maps to 10FFEFh, rather than FFEFh as on older processors without an A20 line.
Now on to protected mode.
With protected mode, the segment registers do not store a portion of the physical address. Rather, each stores a 'selector', which can best be thought of as an index into a table of records (called 'descriptors'). Each descriptor stores certain things about the segment in question, such as the starting physical address (base), the size of the segment (limit), whether it expands upwards (normal) or downwards (used for stacks), the privilege level of the segment, whether it is readable, writable, and/or executable, and if it is present in memory (used for implementing one type of virtual memory). This allows memory protection to be achieved in hardware, as the CPU will raise an exception if an invalid memory operation is attempted. In some cases, this will cause the operating system to terminate the offending process, but in other cases (particularly with regards to virtual memory) it will be handled in a transparent manner (swapping in the memory from disk, for example). With 16-bit protected mode, the system can access up to 16 MB of memory (by specifying a large enough base address), but like in real mode, each segment is limited to 64k in size (as that is the size of the offset register used). In 32-bit protected mode, the full 32-bit address space could be used, by specifying a 4 GB limit. In fact, some old real-mode memory managers (notably HIMEM.SYS) used this trick: they would switch the processor into 32-bit protected mode, create descriptors with a 4-gig limit, load the selectors for those descriptors into the relevant segment registers, and drop back into real mode. As changing the segment register values in real mode would not change selectors (since selectors were only for protected mode), the descriptors would not be changed again as long as the system remained in real mode. This allowed 386+ machines to address the full range of memory through address-size overrides, which in turn made copying blocks of memory a lot faster, since it could all be done from real mode, without performance-heavy mode switches, and was a major factor in improved performance of XMS and EMS drivers on these machines.
Anyways, that's probably enough to digest for now. More than you ever wanted to know about the ugly x86 segmented architecture, no?