20/03/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 objet make_shared suivi de classe A ou paramètres du constructeur sont possibles.
17/03/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- ---------- vecteur peut attribuer (n, chiffres), l'expansion peut redimensionner automatiquement (taille), changer la taille, grande capacité, réserve d'extension active peut changer la capacité.
Après plus Redimensionner, comme si l'affectation par défaut 0, après redimensionne plus petite, plus petite taille, mais l'accès peut l'emplacement d'origine, mais aussi la valeur d'origine, le contenu de la mémoire physique n'a pas changé.
fil de récupération en temps opportun, d' éviter les fuites de ressources https://www.cnblogs.com/liangjf/p/9801496.html
Multithreading paramètres de CMake:
find_package (Threads)add_executable (myapp main.cpp ...)target_link_libraries (myapp ${CMAKE_THREAD_LIBS_INIT})
Std :: mutex mutex et variable de condition std :: condition_variable
- >>> std :: mutex : std :: mutex est la plus élémentaire C ++ mutex offrepropriété exclusive de propriétés, std :: mutex fournit les fonctions membres suivantes:
Constructeur: std :: configuration mutex ne peut être copié, la copie n'est pas autorisé déplacer l'objet mutex a été créé à l' origine est à l'état déverrouillé.
serrure (): thread appelant verrouille le mutex, thread appelle cette fonction , les trois conditions suivantes sont réunies:
(1) si le mutex est pas verrouillé, le fil est appelé le mutex, jusqu'à appeler déverrouillage, le fil avait toujours la serrure.
(2) Si le mutex courant est verrouillé par un autre thread, le thread courant est bloqué des appels en direct.
(3) Si le mutex est actuellement en cours d' appel verrouillé fil, il sera une impasse ,, qui n'est pas permis de bloquer deux fois dans le même fil.
déverrouillage (): Débloquer et la propriété de libération du mutex.
try_lock (): essayez de mutex de verrouillage si le mutex est occupé par d' autres threads, le thread courant ne sera pas bloqué, thread appelle la fonction apparaît les trois cas suivants:
(1) si le mutex actuel n'est pas autres possession de fils, le verrou fil de mutex, déverrouiller jusqu'à ce que les appels de fil libérer le mutex.
(2) Si le mutex courant est verrouillé par un autre thread, le thread appelant courant retourne faux, et ne sera pas bloqué.
(3) Si le mutex actuel appelle actuellement verrouillé fil, il sera une impasse.
Condition variables std :: condition_variable:
la variable condition est une structure de contrôle de la programmation concurrente. Lorsque plusieurs threads d' accéder à une ressource partagée (également connu sous le nom des sections critiques), non seulement besoin de mettre en œuvre un accès exclusif avec un mutex d'erreurs , éviter de concurrence (appelé préjudice à la concurrence), après avoir obtenu le mutex entrer dans la région critique doivent également vérifier certaines conditions est établie : C ++ 11 introduit une variable d'état, à la fois dans son contenu <condition_variable> in. Cela introduit la classe std :: condition_variable.
(1), si les conditions ne sont pas remplies avec du fil de mutex devrait libérer le mutex, l'auto-bloquant (bloc) et bloquer (suspendre) le fil variable état file d'attente
Discussion (2), si les conditions sont remplies, avec l'accès fil mutex à des ressources partagées dans des domaines critiques, d'informer (notifier) de la file d'attente bloquée dans les variables de condition de fil lors de la sortie de la section critique, le fil doit être notifiée réappliquer le mutex.
Std :: variables de condition condition_variable pour la communication entre plusieurs threads, ou il peut bloquer une pluralité de fils simultanément bloqués. std :: condition_variable besoin d'être utilisé en conjonction avec std :: unique_lock. l'effet est équivalent à std :: condition_variable bibliothèque pthread tassée pthread_cond _ * () famille de fonctions.
Lorsqu'une fonction d'attente objet std :: condition_variable est appelé, il utilise std :: unique_lock pour bloquer le thread en cours (via std :: mutex). Le thread courant sera toujours bloqué jusqu'à ce qu'un autre thread appelle une fonction de notification sur le même objet std :: condition_variable pour réveiller le thread courant.
std :: condition_variable utiliser régulièrement std :: unique_lock <std :: mutex> attente, le cas échéant en utilisant le type fermant à clé supplémentaire, peut être utilisé std :: classe condition_variable_any.
Std de condition_variable fonctions membres de la classe:
(1), le constructeur: seul constructeur par défaut, copier, déplacer et affectation (déplacement) sont désactivées.
(2), attendez: le thread courant appelle l'attente () sera bloqué jusqu'à ce que d'autres appels de fil notify_ * sillage du thread courant, lorsque le fil est bloqué, cette fonction appellera automatiquement le std :: mutex déverrouillage () libère le verrou de sorte que les autres bloqués sur fil de contention de verrouillage pour continuer l' exécution. Une fois que le thread courant à notifier (notifier, généralement d'autres appels de fil notify_ * réveiller le thread en cours), la fonction d' attente () est appelée automatiquement std :: mutex de verrouillage est ().
attendre divisé inconditionnellement bloqué et bloqué avec deux types de conditions.
- >>> bloqué sans conditions: avant d' appeler cette fonction, le thread courant devrait déjà unique_lock <mutex> LCK verrouillage complet. Tous utilisent le même fil variable de condition doit utiliser la même unique_lock <mutex> en fonction d'attente . L'attente fonction interne appellera automatiquement lck.unlock () pour déverrouiller le mutex afin que d' autres bloqué l' exécution de la reprise fil mutex. Cette fonction utilise le thread courant est bloqué après avoir obtenu l'avis (notification, par un autre thread appelle notify_ famille * des fonctions) et se réveiller, la fonction d' attente () restaure l'exécution et lck.lock () automatiquement appel à la mutex .
- >>> est bloqué avec une condition: la fonction d'attente définit le prédicat, la condition pred (prédicats) que lorsque les blocs fonctionnels attente de ce que le thread courant est faux Invoqué, et après avoir reçu l'avis d'autres threads est que lorsque pred il sera débloquée lorsque vrai. Ainsi, tout en équivalent (! Pred ()) attente (LCK).
(3), wait_for: Similaire à attendre (), juste wait_for vous pouvez spécifier une période de temps, notifiée dans le thread en cours ou avant que le temps expire, le thread sera état bloqué. Une fois ou reçu un avis d'autres threads, wait_for retour, semblable au reste des étapes et attendre.
(4), wait_until: et wait_for similaire, mais wait_until pouvez spécifier un point dans le temps avant que le thread courant est notifié ou l'expiration du délai imparti, le thread sera état bloqué. Une fois ou reçu un avis d'autres fils, wait_until retour, le reste des étapes de traitement et d'attendre la même.
(5), notify_all: Réveillez-vous tous les fils attendent, si aucun fil d'attente, la fonction ne fait rien.
(6), notify_one: réveillez-vous un fil d'attente, s'il n'y a pas thread courant d'attente, la fonction ne rien faire, s'il y a plusieurs threads en attente, puis se réveiller un fil est incertain (non spécifié).
Changements en présence de parasites réveil, donc après que le fil se réveille pour vérifier si les conditions sont remplies. Que ce soit ou notify_all notify_one sont semblables au signal pulsant, si l'appel d'attente se produit après notification ne se réveille pas, afin que le destinataire avant d'utiliser attente d'attente doivent également vérifier si les conditions sont remplies.
std :: condition_variable_any std :: classe d'utilisation condition_variable avec le même, sauf que seul le std d'attente :: fonction condition_variable_any fermant à clé peut accepter tous les paramètres, std :: condition_variable accepter que std :: unique_lock <std :: mutex> Type de paramètre .
std :: fonction notify_all_at_thread_exit: Lorsque la fonction est appelée sorties de fil, le tout sur la variable condition cond threads en attente sera informé.
référence:
https://www.cnblogs.com/depend-wind/articles/10108048.html
https://www.cnblogs.com/zhanghu52030/p/9166737.html
11/03/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------
groupe de classe A, comprenant en a, b sont deux moyens par lesquels un appel à b, et b est le virtuel;
Les classes dérivées B, la réécriture b, c mais aussi une nouvelle fonction d'écriture;
pointeur de la classe de base p points à l'objet B, ne peut pas être appelé c, parce qu'il ne sait pas qu'il y ait une telle fonction de classe dérivée;
appel p une fonction du temps, un tour appelle la fonction b, car il est virtuel et B également réécrite, donc appellerons B est b.
06/03/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- --------------------
std::atan(y/x)
std::atan2(y, x)Atan cas, pour faire en sorte que x ne correspond pas à 0; x est égal à 0 de atan2 permis, aucune considération particulière. Est-ce que nous devons considérer la division de distribution ne risque égal à zéro.
Ne pas utiliser abs (), usines de fabrication () c de cette bibliothèque, unifiée avec std :: abs ()
05/03/2020 --------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------
enum avec classe ENUM:
1.3 Question 3: enum la portée
de l'ENUM « {} » champ accolades membres visibles et non limitatifs énumérés accolades, ce qui les membres de ENUM exposés à un champ (phrases de bloc).
Par exemple:
#include <iostream>
enum color{red,blue};//定义拥有两个成员的enum，red和blue在enum的大括号外部可以直接访问，而不需要使用域运算符。
int main() {
std::cout << blue << std::endl;
std::cin.get();
return 0;
}Comme le code ci-dessus, nous pouvons y accéder en dehors des accolades bleu, les membres de la couleur a été divulgué à la portée globale du fichier (bien qu'il ne dispose pas de liens externes nature). Il est accessible directement, sans l'aide des opérateurs de domaine.
Mais ce n'est pas critique, mais parfois nous trouvons qu'il est très pratique. Voici le problème:
Problème: Vous ne pouvez pas définir l'énumération des membres du même nom
enum color { red, blue };
//enum MyEnum { red, yellow }; ERROR, 重定义；以前的定义是“枚举数”Comme le montre le code ci-dessus: impossible à réutiliser l'identificateur rouge. En couleur, car il a été utilisé. Cependant, ils tapent clairement dénombrées est différent, si vous pouvez utiliser le même nom de membre, alors accessible par l'opérateur de domaine, puis, merveilleux! Comme ceci:
La couleur rouge
Mais ceci est une version plus ancienne de ENUM ne peut pas faire.
L'introduction du domaine, le domaine est accessible par l'opérateur, ne peut pas accéder directement (afin que nous puissions définir le même membre du corps d'énumération sans erreur de redéfinition eu lieu) en dénombrant nom de membre du corps
#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;
}
Essayez d'utiliser au lieu d'utiliser typedef
//typedef std::shared_ptr<FeatureInfo> FeatureInfo_Ptr;
using FeatureInfo_Ptr = std::shared_ptr<FeatureInfo>;push_back (), dans le cas de taille connue à la réserve (), un système d'accès aléatoire sans nécessiter la liste d'utilisation
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------------
memsetMemset () fonction prototype extern void * memset (tampon void *, int c, int count) tampon: ou d'un tableau de pointeurs,
c: est la valeur attribuée à la mémoire tampon,
count: est la longueur de la mémoire tampon.
// traitement de la valeur absolue de type int, int abs (int i)
// traitement de la valeur absolue de type double, à double usines de fabrication (double-i)
flotter fabsf (float i); / valeur absolue de processus de type float
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- ----------------------
1 vecteur <privé :: Matrix4d, privé :: aligned_allocator <privé :: Matrix4d >>
2, bitset
3, int *, static_cast <int *>, reinterpret_cast <int *> 不 一样;
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -----------------------
Est défini en fonction virtuelle, le nom de la fonction existe après l'héritage, mais des comportements différents peut être utilisé un pointeur de base ou un point de référence;
BCD sont héritées de A, vous pouvez utiliser le pointeur sur le point A, ce qui conduit à un tableau « Enregistrer » différents types de BCD, peu importe quel type, si elles sont présentes une fonction virtuelle du même nom, l'appel est BCD sa manière, Si non défini en fonction virtuelle, puis les méthodes de la classe de base sont appelés en aucun cas;
Si vous n'utilisez le pointeur de base à une classe différente, et appelle la même fonction, il n'y a pas de fonctions virtuelles doivent être définies, de toute façon, ne modifient pas la fonction d'appel de la classe mère
-------------------------------------------------- -------------------------------------------------- -------------------------------------------------- -------------------- temps chrono:
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
