2-1 obsoleta función de referencia variable de lenguaje C
1. plantilla en lugar de parámetro variable función del lenguaje C
2. std :: enable_if proceso longitud de referencia variable es cero
2-2 convención de nombres de subrayado
1. No subraye el archivo de cabecera macro
2. operador definido por el usuario subrayado
variables de campo de archivo 3. Definición no lo hacen subrayado
4. Evitar el uso duplicado y el C ++ estándar nombre de la macro
2-3 referencias
1. No const / volátil precedido por referencia: (char y const p)
referencia 2.const no puede ser reasignado
2-4 semántica ambigua
Error Definición Ejemplo:
1. std :: unique_lock <std :: mutex> (m);
2. Widget w ();
2-5 mientras sobrecargado Asignar y desasignar
1. Asegúrese de sobrecarga de nuevo sobrecargados de eliminación
2-5 pérdida de datos como un parámetro pasado a impedir que la clase
Correspondiente al copy_to_user extern int (* dest vacío, void * src, std :: size_t tamaño); similares
1. Cada miembro de transferencia de parámetros transmitido de forma individual
2. Uso static_assert () y offsetof () para asegurar la consistencia de la longitud del miembro
3. Para cada miembro, y el registro acumulativo offset, código de ejemplo:
1 #include <cstddef> 2 #include <cstring> 3 clase de base { 4 público : 5 virtual ~ base de () = por defecto ; 6 }; 7 8 clase de prueba: público virtual de base { 9 alignas ( 32 ) doble h; 10 Char i; 11 j sin signo: 80 ; 12 protegida : 13 k sin signo; 14 l sin signo: 4 ; 15 unsigned corto m: 3 ; 16 pública : 17 Char n; 18 doble o; 19 de ensayo ( doble h, Char i, j sin signo, k sin signo, sin signo l, sin signo corto m, Char n, doble o): 20 h (h), i (i), j (j), k (k), l (l), m (m), n (n), o (o) {} 21 virtual void foo (); 22 bool serialize (sin firmar Char * buffer, std :: size_t ytamaño) { 23 si (tamaño < sizeof (test)) {} retorno falsa ; 24 std :: size_t offset = 0 ; 25 std :: memcpy (tampón + offset, & h, sizeof (h)); compensar + = sizeof (h); 26 std :: memcpy (tampón + offset, + i, sizeof (i)); compensar + = sizeof (i); 27 // Sólo sizeof (sin firmar) bits son válidos, por lo que la siguiente es // no reduciendo. 28 loc_j unsigned = j; 29 std :: memcpy (tampón + offset, y loc_j,sizeof (loc_j)); compensar + = sizeof (loc_j); 30 std :: memcpy (tampón + offset, y k, sizeof (k)); 31 desplazamiento + = sizeof (k); 32 unsigned char loc_l = l & 0b1111; 33 std :: memcpy (tampón + offset, y loc_l, sizeof (loc_l)); compensar + = sizeof (loc_l); 34 unsigned corto loc_m = m y 0b111; 35 std :: memcpy (tampón + offset, y loc_m, sizeof (loc_m)); compensar + = sizeof (loc_m); 36 std :: memcpy (tampón + offset, y n, sizeof (n)); 37 desplazamiento + = sizeof (n); 38 std :: memcpy (tampón + offset, & o, sizeof (o)); 39 compensar + = sizeof (o); 40 tamaño - = offset; 41 regresan verdadera ; 42 } 43 44 // forma segura copiar bytes de espacio de usuario. 45 extern int copy_to_user ( void * dest, void * src, tamaño size_t); 46 47 nulado_stuff ( void * usr_buf) { 48 arg prueba { 0,0 , 1 , 2 , 3 , 4 , 5 , 6 , 7.0 }; 49 // puede ser más grande de lo estrictamente necesario, se actualizará por // llamando serialize () para el tamaño de la memoria intermedia restante. 50 std :: tamaño size_t = sizeof (arg); 51 unsigned char buf [ sizeof (arg)]; 52 Si (arg.serialize (buf, tamaño)) { 53 copy_to_user (usr_buf, buf, sizeof (test) - tamaño); 54 } más { 55 // error mango 56 } 57 } 58 };