user101040: The CBlockLocator strucuture's purpose is:

Describes a place in the block chain to another node such that if the
other node doesn't have the same branch, it can find a recent common
trunk. The further back it is, the further before the fork it may be.

/** Describes a place in the block chain to another node such that if the
 * other node doesn't have the same branch, it can find a recent common trunk.
 * The further back it is, the further before the fork it may be.
 */
struct CBlockLocator
{
    std::vector<uint256> vHave;

But it's not clear to me how does it works. How does the sender specify the Block with A in this structure? Does the vHave contains a list of contiguous block hashes previous to A and A itself?

user48884: 
Does the vHave contains a list of contiguous block hashes previous to A and A itself?

Pretty much.
CBlockLocators are just a list of block hashes, with most recent blocks first. Of course, it would be expensive to send all of the block hashes that precede A, so the list contains hashes farther and farther apart as the blocks get older.
It starts with A and the 9 blocks that came before it. The vast majority of reorgs will be within these 10 blocks, so it just lists all 10 and there's a pretty high likelihood that the forking point will be in there. But after that, hashes start being spaced out exponentially. It starts with 2 blocks before the last in the list, then 4, then 8, and so on, until the genesis block is reached.
The list ends up having ceil(log2(n)) + 11 hashes. Currently that's 31 block hashes.

101040: <p>The <a href="https://github.com/bitcoin/bitcoin/blob/6b24dfe24d2ed50ea0b06ce1919db3dc0e871a03/src/primitives/block.h#L120" rel="nofollow noreferrer">CBlockLocator</a> strucuture's purpose is:</p>
<blockquote>
<p>Describes a place in the block chain to another node such that if the
other node doesn't have the same branch, it can find a recent common
trunk. The further back it is, the further before the fork it may be.</p>
</blockquote>
<pre><code>/** Describes a place in the block chain to another node such that if the
 * other node doesn't have the same branch, it can find a recent common trunk.
 * The further back it is, the further before the fork it may be.
 */
struct CBlockLocator
{
    std::vector&lt;uint256&gt; vHave;
</code></pre>
<p>But it's not clear to me how does it works. How does the sender specify the Block with <code>A</code> in this structure? Does the <code>vHave</code> contains a list of contiguous block hashes previous to <code>A</code> and <code>A</code> itself?</p>
 48884: <blockquote>
<p>Does the <code>vHave</code> contains a list of contiguous block hashes previous to <code>A</code> and <code>A</code> itself?</p>
</blockquote>
<p>Pretty much.</p>
<p><code>CBlockLocators</code> are just a list of block hashes, with most recent blocks first. Of course, it would be expensive to send all of the block hashes that precede <code>A</code>, so the list contains hashes farther and farther apart as the blocks get older.</p>
<p>It starts with <code>A</code> and the 9 blocks that came before it. The vast majority of reorgs will be within these 10 blocks, so it just lists all 10 and there's a pretty high likelihood that the forking point will be in there. But after that, hashes start being spaced out exponentially. It starts with 2 blocks before the last in the list, then 4, then 8, and so on, until the genesis block is reached.</p>
<p>The list ends up having <code>ceil(log2(n)) + 11</code> hashes. Currently that's 31 block hashes.</p>
