03/20/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------
class A{
A(input){
temp = input;
}
private:
int temp;
}
A a(5);
std::shared_ptr<A> p(new A);
std::shared_ptr<A> p = std::make_shared<A>(a);
std::shared_ptr<A> p = std::make_shared<A>(5);
Un objeto make_shared seguido de clase A o parámetros de constructor son posibles.
03/17/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- ---------- vector puede asignar (n, dígitos); de expansión puede cambiar automáticamente el tamaño (tamaño), cambiar el tamaño, de gran capacidad; reserva de extensión activo puede cambiar la capacidad.
Después de más de cambio de tamaño, como si la asignación por defecto 0, después de cambiar el tamaño más pequeño, tamaño más pequeño, pero el original acceso a la ubicación lata, sino también el valor original, el contenido de la memoria física no ha cambiado.
enhebrar la recuperación oportuna, prevenir fugas de recursos https://www.cnblogs.com/liangjf/p/9801496.html
Multithreading configuración cmake:
find_package (Threads)add_executable (myapp main.cpp ...)target_link_libraries (myapp ${CMAKE_THREAD_LIBS_INIT})
Std :: mutex mutex y std :: estado variable condition_variable
- >>> std :: mutex : std :: mutex es el básico de C ++ mutex más ofrece la propiedad exclusiva de propiedades, std :: mutex proporciona las siguientes funciones miembro:
Constructor: configuración std :: mutex no puede ser copiado, la copia no se permite movimiento, el objeto mutex fue creado originalmente está en el estado desbloqueado.
bloqueo (): llamar hilo se bloqueará el mutex, hilo llama a esta función se dan las tres condiciones siguientes:
(1) si el mutex no está actualmente bloqueado, el hilo se llama el bloqueo de exclusión mutua, hasta llamar de desbloqueo, el hilo siempre tenía la cerradura.
(2) Si el mutex llamadas actual está bloqueado por otro subproceso, el subproceso actual se bloquea viven.
(3) Si el mutex actual está bloqueado actualmente llamando hilo, será un punto muerto ,, que no está permitido para bloquear dos veces en el mismo hilo.
de desbloqueo (): desbloqueo y la propiedad de liberación de la exclusión mutua.
try_lock (): tratar de exclusión mutua bloqueo si el mutex es ocupado por otros hilos, el hilo actual no será bloqueada, subproceso llama a la función aparecerán los siguientes tres casos:
(1) Si el mutex actual no es otros hilos posesión, el bloqueo mutex hilo, de desbloqueo hasta que las llamadas de rosca liberar el mutex.
(2) Si el mutex actual está bloqueado por otro hilo, el hilo de llamadas actual devuelve falso, y no será bloqueada.
(3) Si el mutex actual está bloqueado actualmente llamando hilo, será un punto muerto.
condición variable std :: condition_variable:
variable de condición es una estructura de control de la programación concurrente. Cuando varios subprocesos tienen acceso a un recurso compartido (también conocido como secciones críticas), no sólo es necesario para implementar el acceso exclusivo con un mutex para evitar errores de concurrencia (llamado daño a la competencia), después de obtener el mutex entrar en la región crítica También es necesario comprobar ciertas condiciones se establece : C ++ 11 introduce una variable de condición, tanto en su contenido <condition_variable> en. Esto introduce la clase std :: condition_variable.
(1), si las condiciones no se satisfacen con hilo mutex debe liberar el mutex, la auto-bloqueo (bloque) y colgar (suspender) la cola de hilo variable de condición
Hilo (2), si se cumplen las condiciones, con el hilo de acceso a los recursos compartidos de exclusión mutua en áreas críticas, para informar (notificar) de la cola bloqueados en las variables de condición de rosca al salir de la sección crítica, el hilo debe ser notificado volver a solicitar el bloqueo de exclusión mutua.
Std :: condición variables de condition_variable para la comunicación entre múltiples hilos, o puede bloquear una pluralidad de hilos simultáneamente bloqueados. std :: necesidad condition_variable a ser usado en conjunción con std :: unique_lock. el efecto es equivalente a std :: condition_variable embalado pthread_cond biblioteca pthread _ * familia () de funciones.
Cuando una función de espera std :: condition_variable objeto se llama, utiliza std :: unique_lock para bloquear el hilo actual (a través de std :: mutex). El hilo actual siempre será bloqueado hasta que otro hilo llama a una función de notificación en la misma std :: condition_variable objeto de despertar el subproceso actual.
std :: condition_variable utilizar regularmente std :: unique_lock <std :: mutex> espera, si es necesario, utilizando el tipo de cerradura adicional, puede ser utilizada std :: condition_variable_any clase.
condition_variable funciones miembro de clase std :::
(1), el constructor: Sólo por defecto constructor, copiar, misiones y mover (mover) están desactivados.
(2), esperar: el subproceso actual llama a la espera () será bloqueado hasta que algún otro subproceso llama notify_ estela * del hilo actual; cuando el hilo está bloqueado, esta función llamará automáticamente al desbloqueo std :: mutex () libera el bloqueo de manera que otra bloqueado en hilo de contención de bloqueo para continuar la ejecución. Una vez que el hilo actual para ser notificado (notificar, por lo general algunas otras llamadas hilo notify_ estela * el hilo actual), función de espera () se invoca automáticamente std :: mutex bloqueo es ().
Dividido esperar incondicionalmente bloqueado y bloqueado con dos tipos de condiciones.
- >>> incondicionalmente bloqueado: antes de llamar a esta función, el hilo actual ya debe unique_lock <mutex> lck bloqueo completo. Todo el uso de la misma condición variable de subproceso debe utilizar el mismo unique_lock <mutex> en función de espera . La función interna de espera llamará automáticamente lck.unlock () para desbloquear el mutex para que otra bloqueado reanudó el hilo de ejecución mutex. Esta función utiliza el subproceso actual se bloquea después de recibir la notificación (notificado, por otro subproceso llama notify_ familia de funciones *) y despertar, la función de espera () restaura la ejecución y lck.lock llamada automáticamente () para el bloqueo de exclusión mutua .
- >>> se bloquea con una condición: función de espera establece el predicado (predicado), condición pred sólo cuando los bloques de función espera será el hilo actual se falsa invocado, y después de recibir la notificación de otros hilos es sólo cuando pred será desbloqueado cuando es verdadero. Así, mientras equivalente (! Pred ()) de espera (LCK).
(3), wait_for: Similar a wait (), solo wait_for puede especificar un período de tiempo, notificado en el hilo actual o antes de que expire el tiempo especificado, el hilo será bloqueado estado. Una vez fuera o haber recibido una notificación de otros hilos, wait_for retorno, similar al del resto de los pasos y espera.
(4), wait_until: y wait_for similar, pero wait_until pueden especificar un punto en el tiempo antes de que el hilo actual es notificado o el tiempo especificado, el hilo será bloqueado estado. Una vez fuera o haber recibido una notificación de otros hilos, wait_until cambio, el resto de las etapas de procesamiento y esperar similar.
(5), notify_all: se despiertan todos los subprocesos esperan, si no hay hilo de espera, la función no hace nada.
(6), notify_one: despertar una espera de hilo, si no hay un hilo actual que esperar, entonces la función no hace nada; si hay varios subprocesos en espera, entonces se despierta un hilo es incierto (no especificado).
Los cambios en la presencia de wakeup espuria, por lo que después de que el hilo se despierta para comprobar si se cumplen las condiciones. Sea o notify_all notify_one son similares a la señal pulsante, si la llamada que esperar produce después de notificar no se despierta, para que el destinatario antes de usar espera espera También es necesario comprobar si se cumplen las condiciones.
std :: condition_variable_any std :: Clase de uso condition_variable con el mismo, excepto que sólo el std :: espera condition_variable_any función de cerradura puede aceptar ningún parámetro, std :: condition_variable sólo aceptan std :: unique_lock <std :: mutex> Tipo de parámetro .
función std :: notify_all_at_thread_exit: Cuando la función se llama hilo termina, todas las variables de la condición cond los subprocesos en espera serán notificados.
referencia:
https://www.cnblogs.com/depend-wind/articles/10108048.html
https://www.cnblogs.com/zhanghu52030/p/9166737.html
03/11/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------
Clase Grupo A, que comprende a, b son dos formas en las que una llamada a B, y B es el virtual;
Las clases derivadas B, reescribiendo b, c, sino también una nueva función de escritura;
Base puntero de clase p apunta al objeto B, no pueden ser llamados c, porque él no sabe que hay tal función de una clase derivada;
p llamada en función del tiempo, una vez llama a la función B, porque es virtual y B también reescrito, por lo que la llamada a B es b.
06/03/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- --------------------
std::atan(y/x)
std::atan2(y, x)Atan caso, para asegurarse de que x no es igual a 0; x es igual a 0 de atan2 permitido, sin consideración especial. Por qué debemos tener en cuenta la división de distribución no correrá el riesgo igual a cero.
No utilice abs (), FABS (c) de esta biblioteca, unificados con std :: abs ()
05/03/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------
enum con la clase de enumeración:
1.3 Pregunta 3: enum el alcance
de la enum "{}" campo de los apoyos de elementos limitadores de la visible y no enumerados en los frenos, dando como resultado los miembros de enumeración expuestos a un ámbito de aplicación (sentencias de bloque).
Por ejemplo:
#include <iostream>
enum color{red,blue};//定义拥有两个成员的enum，red和blue在enum的大括号外部可以直接访问，而不需要使用域运算符。
int main() {
std::cout << blue << std::endl;
std::cin.get();
return 0;
}Como el código anterior, podemos acceder a él fuera de las llaves azules, miembros del color fue filtrado al alcance global del archivo (aunque no tiene la naturaleza de enlaces externos). Se puede acceder directamente, sin la ayuda de los operadores de dominio.
Pero esto no es crítico, pero a veces resulta muy conveniente. Aquí está el problema:
Problema: No se puede definir de enumeración miembros con el mismo nombre
enum color { red, blue };
//enum MyEnum { red, yellow }; ERROR, 重定义；以前的定义是“枚举数”Como se muestra en el código anterior: no se puede reutilizar el identificador de rojo. En color, ya que se ha agotado. Tipo Sin embargo, es obvio que enumeraron es diferente, si se puede usar el mismo nombre de usuario, puede acceder a continuación por el operador de dominio y, a continuación, qué maravilloso! De esta manera:
color rojo
Pero esta es una versión anterior de enumeración no puede hacer.
La introducción del dominio, el dominio que se accede por el operador, no se puede acceder directamente (por lo que podemos definir el mismo elemento de cuerpo enumeración sin error redefinición ocurrido) mediante la enumeración de nombre de elemento de cuerpo
#include <iostream>
enum class color { red, green, yellow};
enum class colorX { red, green, yellow };
int main() {
//使用域运算符访问枚举体成员，强转后打印
std::cout << static_cast<int>(color::red) << std::endl;
std::cout << static_cast<int>(colorX::red) << std::endl;
std::cin.get();
return 0;
}
Trate de usar en lugar de utilizar typedef
//typedef std::shared_ptr<FeatureInfo> FeatureInfo_Ptr;
using FeatureInfo_Ptr = std::shared_ptr<FeatureInfo>;push_back (), en el caso de tamaño conocido a la reserva (), un sistema de acceso aleatorio sin requerir la lista de uso
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------
memsetMemset () la función prototipo extern void * memset (* búfer vacío, int c, int count) Tampón: o matriz de punteros,
c: es el valor asignado a la memoria intermedia,
cuenta: es la longitud de la memoria intermedia.
// procesamiento del valor absoluto de tipo int; int abs (int i)
// procesamiento del valor absoluto de tipo doble; FABS dobles (doble i)
flotar fabsf (flotar i); / valor absoluto de proceso de tipo float
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------------------
1 vector <Privado :: Matrix4d, Privado :: aligned_allocator <Privado :: Matrix4d >>
2, bitset
3, int *, static_cast <int *>, reinterpret_cast <int *> 不 一样;
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------------------
Se define como una función virtual, existe el nombre de la función después de la herencia, pero diferentes comportamientos se puede utilizar un puntero base o un punto de referencia;
BCD son heredados de A, puede usar el puntero para el punto A, lo que conduce a una matriz "Guardar" diferentes tipos de BCD, no importa qué tipo, si están presentes una función virtual con el mismo nombre, la llamada está en BCD a su manera, Si no se define como una función virtual, a continuación, los métodos de la clase de base se denominan en cualquier circunstancia;
Si no se utiliza el puntero de base para una clase diferente, y llama a la misma función, no hay funciones virtuales deben definirse, de todos modos, no afectan a la función de llamada de la clase padre
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------- temporización crono:
std::chrono::steady_clock::time_point start = std::chrono::steady_clock::now();
LandmarkFeatureExtracter::extract(scan, features);
GeometryFeatureExtracter::extract(scan, features);
std::chrono::steady_clock::time_point end = std::chrono::steady_clock::now();
std::chrono::steady_clock::duration used_time = end-start;
std::cout << "used time: " << std::chrono::duration_cast<std::chrono::milliseconds>(used_time).count() << std::endl;https://www.cnblogs.com/bianchengnan/p/9478638.html
