template <class Archive>
void serialize(Archive& archive, unsigned const version)
{
    archive & m_something; // это что?
    Archive & oops;        // а вот это?
}

ns::foo s = getSomeFoo();
ns::bar t;
ns2::quux u;
const ns::foo v = getSomeFoo()
const ns2::bar w = getSomeBar()
ns::quux x = getSomeQuux();
ns2::quuux y;
ns2::quuuux z = getSomeQuuuux();

ns::foo s = getSomeFoo();
ns::bar t;
ns2::quux u;
ns::foo const v = getSomeFoo()
ns2::bar const w = getSomeBar()
ns::quux x = getSomeQuux();
ns2::quuux y;
ns2::quuuux z = getSomeQuuuux();

Exceptions
▶ We do not use C++ exceptions.

E>>call_function_with_very_long_name( first_argument,
E>>                                   call_another_function_for_second_argument( param1,
E>>                                                                              call_yet_another_function() ),
E>>                                   some_expression * as / third - argument );
E>>

J>стреляться не хочу, так что выбираю сопровождать

call_function_with_very_long_name(
    first_argument,
    call_another_function_for_second_argument(
        param1,
        call_yet_another_function() ),
    some_expression * as / third - argument );

so_add_destroyable_traits(
        new so_msg_templ_postman_t< msg_send_finish >(
                so_query_name(),
                "msg_send_finish",
                and_analyzer(
                        dest_equality_analyzer( 
                                mbox_dest_t( cfg.m_listening_mbox ) ),
                        not_rerouted_by_analyzer( so_query_name() ) ),
                cfg.m_interception_priority,
                intercept_msg ) );

bool MemoryStream::ReserveSize(size_t size) {
  if (allocated_length_ >= size)
    return true;

  //!!! std::nothrow missed
  if (char* new_buffer = new char[size]) {
    memcpy(new_buffer, buffer_, data_length_);
    delete [] buffer_;
    buffer_ = new_buffer;
    allocated_length_ = size;
    return true;
  }

  return false;
}

XmppSocket::XmppSocket(bool tls, const std::string& user_agent, const talk::ProxyInfo& proxy)
    : tls_(tls) 
{
  talk::Thread* pth = talk::Thread::Current();
  cricket_socket_ = pth->socketfactory()->CreateAsyncSocket(SOCK_STREAM);
  //!!! NO ERROR CHECK - CreateAsyncSocket() RETURNS 0 ON ERROR

  ...
}

  if (proxy_.type) {
    talk::AsyncSocket * proxy_socket = 0;
    if (proxy_.type == talk::PROXY_SOCKS5) {
      proxy_socket = new talk::AsyncSocksProxySocket(socket, proxy_.address,
        proxy_.username, proxy_.password);
    } else {
      // Note: we are trying unknown proxies as HTTPS currently
      proxy_socket = new talk::AsyncHttpsProxySocket(socket,
        agent_, proxy_.address,
        proxy_.username, proxy_.password);
    }
    if (!proxy_socket) {
      //!!! HOW CAN WE GET HERE???
      delete socket;
      return 0;
    }
    socket = proxy_socket;  // for our purposes the proxy is now the socket
  }

Names and Order of Includes
▶ Use standard order for readability and to avoid hidden dependencies: C library, C++ library, other libraries' .h, your project's .h.

WH>using (Stream file1 = File.Open(...))
WH>using (Stream file2 = File.Open(...))
WH>using (Stream file3 = File.Open(...))
WH>using (Stream file4 = File.Open(...))
WH>{
WH>}
WH>

using (Stream file1 = File.Open(...))
{
  // что-то делаем
  using (Stream file2 = File.Open(...))
  {
    // что-то делаем
    using (Stream file3 = File.Open(...))
    {
      // что-то делаем
      using (Stream file4 = File.Open(...))
      {
      }
    }
  }
}

→   if(cond)
→   {
→   →   someFunction(param1, param2, param3,
→   →   ·············param4, param5);
→   }

RO>→   if(cond)
RO>→   {
RO>→   →   someFunction(param1, param2, param3,
RO>→   →   ·············param4, param5);
RO>→   }
RO>

call_function_with_very_long_name( first_argument,
                                   call_another_function_for_second_argument( param1,
                                                                              call_yet_another_function() ),
                                   some_expression * as / third - argument );

Parameters

index
Type: System.Int32
The zero-based index at which item should be inserted.

Exceptions

Exception	Condition
ArgumentOutOfRangeException	index is less than 0. -or- index is greater than Count.

List<int> list;
list.Insert(0, 42);
list.Insert(0, 24);
try
{
    for(int i = 0; i < 2147483646; ++i)
    {
        list.insert(1, 0); // согласно MSDN, исключений не бросает
    }
}
catch(Exception)
{
    Console.WriteLine("Oops!"); // разве что OOM, но предположим, что 8 ГБ памяти в наличии есть
}
Console.WriteLine("{0} {1} {2} {3} {4}",
    list.Count, list.первый_элемент, list.второй_элемент, list.предпоследний_элемент, list.последний_элемент);

WH>...
WH>        Array.Copy(this._items, index, this._items, index + 1, this._size - index);
WH>...
WH>

Array.Copy Method (Array, Int32, Array, Int32, Int32)
...
public static void Copy (
Array sourceArray,
int sourceIndex,
Array destinationArray,
int destinationIndex,
int length
)

...
If this method throws an exception while copying, the state of destinationArray is undefined.
...

std::string const & in

void ramkrishnamahadevmaamabeganeshmaheshwarishardayanamahajaishreeramgaganpateynamahaomhrimshrimchammundiyavicheenamaha(const string* &s);

void f()
{
   Guard1 g1;
   f1();
   f2();
   Guard2 g2;
   f3();
   f4();
}

bool f()
{
   Guard1 g1;
   if (!f1()) return false;
   if (!f2()) return false;
   Guard2 g2;
   if (!f3()) return false;
   if (!f4()) return false;
}

8.3.1 Pointers
1 In a declaration T D where D has the form

* cv-qualifier-seqopt D1

and the type of the identifier in the declaration T D1 is “derived-declarator-type-list T,” then the type of the identifier of D is “derived-declarator-type-list cv-qualifier-seq pointer to T.”

const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
int i, *p, *const cp = &i;

L>Да все о том же. Определенными авторами и их произведениями неокрепших программистов можно напугать до смерти. Вот тут как раз такой случай

Issues that are really just personal taste and don't affect correctness or readability don't belong in a coding standard. Any professional programmer can easily read and write code that is formatted a little differently than they're used to.

Do use consistent formatting within each source file or even each project, because it's jarring to jump around among several styles in the same piece of code. But don't try to enforce consistent formatting across multiple projects or across a company.

Here are several common issues where the important thing is not to set a rule but just to be consistent with the style already in use within the file you're maintaining:

* Don't specify how much to indent, but do indent to show structure: Use any number of spaces you like to indent, but be consistent within at least each file.

* Don't enforce a specific line length, but do keep line lengths readable: Use any length of line you like, but don't be excessive. Studies show that up to ten-word text widths are optimal for eye tracking.

* Don't overlegislate naming, but do use a consistent naming convention: There are only two must-dos: a) never use "underhanded names," ones that begin with an underscore or that contain a double underscore; and b) always use ONLY_UPPERCASE_NAMES for macros and never think about writing a macro that is a common word or abbreviation (including common template parameters, such as T and U; writing #define T anything is extremely disruptive). Otherwise, do use consistent and meaningful names and follow a file's or module's convention. (If you can't decide on your own naming convention, try this one: Name classes, functions, and enums LikeThis; name variables likeThis; name private member variables likeThis_; and name macros LIKE_THIS.)

* Don't prescribe commenting styles (except where tools extract certain styles into documentation), but do write useful comments: Write code instead of comments where possible (e.g., see Item 16). Don't write comments that repeat the code; they get out of sync. Do write illuminating comments that explain approach and rationale.

Finally, don't try to enforce antiquated rules (see Examples 3 and 4) even if they once appeared in older coding standards.

do_something(with(that+and+those)*those-that/(bla(b)-bla(d+f)-bla(c))*0.1);

using (Stream file1 = File.Open(...))
using (Stream file2 = File.Open(...))
using (Stream file3 = File.Open(...))
using (Stream file4 = File.Open(...))
{
}

std::vector<int*> vec;
vec.push_back(new int);

Rationale
...

#include <ostream>
#include <ios>

void  hex_my_byte( std::ostream &os, char byte )
{
    os << std::hex << static_cast<unsigned>(byte);
}

The os stream will retain its new hexadecimal printing mode after the call to hex_my_byte. The stream's printing mode can be saved and restored with manual calls to the stream's state inspecting and mutating member functions. The manual method becomes unwieldy if the main functionality is complex and/or needs to be exception safe. A saver class can implement the better "resource acquisition is initialization" strategy.

Let's say you are developing one of those trendy instant messaging servers. Users can log on and off the system and can send messages to each other. You hold a server-side database of users, plus in-memory information for users who are logged on. Each user can have friends. The list of friends is also kept both in the database and in memory.

When a user adds or removes a friend, you need to do two things: update the database and update the in-memory cache that you keep for that user. It's that simple.

ЮЖ>>std::vector<int*> vec;
ЮЖ>>vec.push_back(new int); 
ЮЖ>>

int* ptr = new int();
try
{
  vec.push_back(ptr); // bad_alloc при переаллокации, соответственно ptr утечет
}
catch(std::exception&)
{
  delete ptr;
  throw;
}

{
  std::auto_ptr<int> ptr(new int());
  vec.push_back(ptr.get());                    
  ptr.release();                     // commit
  // ~auto_ptr rollback
}

MapReduceSpecification spec;
// Store list of input files into "spec"
for (int i = 1; i < argc; i++) {
  MapReduceInput* input = spec.add_input();
  input->set_format("text");
  input->set_filepattern(argv[i]);
  input->set_mapper_class("WordCounter");
}

E>so_add_destroyable_traits(
E>        new so_msg_templ_postman_t< msg_send_finish >(
E>                so_query_name(),
E>                "msg_send_finish",
E>                and_analyzer(
E>                        dest_equality_analyzer( 
E>                                mbox_dest_t( cfg.m_listening_mbox ) ),
E>                        not_rerouted_by_analyzer( so_query_name() ) ),
E>                cfg.m_interception_priority,
E>                intercept_msg ) );
E>

auto var1 = dest_equality_analyzer (mbox_dest_t (cfg.m_listening_mbox));
auto var2 = not_rerouted_by_analyzer (so_query_name());
auto var3 = and_analyzer (var1, var2);

so_add_destroyable_traits
(
        new so_msg_templ_postman_t< msg_send_finish >
        (
                so_query_name(), "msg_send_finish",
                var3, cfg.m_interception_priority, intercept_msg
        )
);

CC>auto var1 = dest_equality_analyzer (mbox_dest_t (cfg.m_listening_mbox));
CC>auto var2 = not_rerouted_by_analyzer (so_query_name());
CC>auto var3 = and_analyzer (var1, var2);
CC>

auto var0 = mbox_dest_t (cfg.m_listening_mbox);
auto var1 = dest_equality_analyzer (var0);
auto var2 = not_rerouted_by_analyzer (so_query_name());
auto var3 = and_analyzer (var1, var2);