C++一些函数的总结

字符串对比长度
typedef std::string::size_type string_size;//字符串的长度，size_type是容器

对比两个字符串是否相等
bool CmdParser::isCmd(std::string cmd_name) { return cmd_name.compare(cmd_name_) == 0; }

s.atof()函数
把字符转换为浮点数

string字符串的s.data()函数的使用
生成一个const char*指针

s.atoi()函数
把字符串转换成整数

s.at(n)函数
返回下标为n的元素的引用

s.find()函数
找到返回字符串的起始位置，没有找到返回-1

遍历vector<std::string>s;
for(std::string arg : s)
{
    写具体的操作
}

s.compare(c)函数的使用
字符串s和c字符串，每个字符去比较，相等输出0，不等输出-1

s.c_str()函数
把string转成char*，最后也是用%s来输出

声名可以多次，定义只能一次

extern int i;//声名
int i;//声名也是定义

<memory>是C++空间配置以及new delete定义的头文件

std::shared_ptr智能指针的使用
一次性分配内存
std::shared_ptr<Test> p = std::make_shared<Test>();
他的头文件#include<memory>

using的使用
为基类成员函数名称而作的using声明将该函数的所有重载实例加到派生类的作用域

int main(int argc, char *argv[])
argc是命令行总的参数个数，
argv[]是argc个参数，
其中第0个参数是程序的全名，以后的参数命令行后面跟的用户出入的参数

#ifndef ,#define,#endif的作用
目的防止该头文件被重复引用

c++中static_cast用法
const 属性用const_cast
基本类型转换用static_cast
多态类之间的类型转换用daynamic_cast
不同类型的指针类型转换用reinterpreter_cast

int sprintf(char *str, const char *format, ...)函数
{
    1.str  //这是指向一个字符数组的指针，该数组存储了 C 字符串。
    2.第二个数是某种格式
    3.第三个数是传入的值
}

readlink(linkpath)函数
{
    1.函数返回符号连接的目标
    2.linkpath必需，规定检查的连接路径
    
    3.如果连接成功，该函数返回连接的目标
    4.如果失败，则返回FALSE
}

shared_ptr智能指针
{
    1.shared_ptr<T> ptr(new T);  // T 可以是 int、char、类等各种类型
    2.通过 shared_ptr 的构造函数，可以让 shared_ptr 对象托管一个 new 运算符返回的指针
    3.此后，ptr 就可以像 T* 类型的指针一样使用，即 *ptr 就是用 new 动态分配的那个对象
    4.多个 shared_ptr 对象可以共同托管一个指针 p，当所有曾经托管 p 的 shared_ptr 对象都解除了对其的托管时，就会执行delete p
    5.
}

make_shared的用法
{
    1.make_shared 在动态内存中分配一个对象并初始化它，返回指向此对象的shared_ptr，与智能指针一样，make_shared也定义在头文件memory中；
    2.当要用make_shared时，必须指定想要创建的对象类型，定义方式与模板类相同，在函数名之后跟一个尖括号，在其中给出类型；
    3.如shared_pre<int> p3 = make_shared<int>(42)；
    4.一般采用auto定义一个对象来保存make_shared的结果，如auto p1 =make_shared<int>(42);
    
    5.  shared_ptr很好地消除了显式的delete调用，如果读者掌握了它的用法，可以肯定delete将会在你的编程字典中彻底消失 。
    6.但这还不够，因为shared_ptr的构造还需要new调用，这导致了代码中的某种不对称性。虽然shared_ptr很好地包装了new表达式，
    
    7.但过多的显式new操作符也是个问题，用make_shared()来消除显式的new调用。
    8.make_shared()函数可以接受最多10个参数，然后把它们传递给类型T的构造函数，

    9.创建一个shared_ptr<T>的对 象并返回。make_shared()函数要比直接创建shared_ptr对象的方式快且高效，
    10.因为它内部仅分配一次内存，消除了shared_ptr 构造时的开销。
    
    11.//make_shared自动申请对象及内存,自动释放,不用手动执行new和delete
    12.shared_ptr<StructA> pA = make_shared<StructA>(123);
    13.cout << "pA->i = " << pA->i << endl;

}

readlink（）函数获取当前路径
{
    1./proc/self/exe 它代表当前程序
    2.所以可以用readlink读取它的源路径就可以获取当前程序的绝对路径
    3.readlink("/proc/self/exe" , buf , sizeof(buf));
}

fd = open(file_path.c_str(), O_RDWR | O_CREAT, 0666);
{
    1.0666代表打开权限
    2.分别有user,group,other等几种权限
    3.user有S_IRUSR,S_IWUSR,S_IXUSR，分别代表read,write,exute（读写执行）的权限用二进制表示成100,010,001
    4.所以6就等于100+010，可以表示成S_IRUSR|S_IWUSR，以此类推
    5.linux还有设置权限位可以设置为 S_ISUSR或者S_ISOTH
    6.0666 = S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH
    7.要包上头文件 sys/stat.h
}

fcntl 记录上锁
{
    1.int fcntl(int fd,int cmd, ...)
    2.cntl函数用于改变已打开文件性质，函数参数是可变参数：
    3.第一个参数 fd 表示打开文件的文件描述符，

　　4.第二个参数是对应的功能指令，不同指令决定不同的后续参数。

　　fcntl 基本用途包括以下五点：

　　1.复制一个现有的描述符（cmd = F_DUPFD）。

　　2.获得/设置文件描述符标记（cmd = F_GETFD或F_SETFL）。

　　3.获得/设置文件状态标志（cmd = F_GETOWN或F_SETOWN）。

　　4.获得/设置异步I/O所有权（cmd = F_GETOWN或F_SETOWN）。

　　5.获得/设置记录锁（cmd = F_GETLK、F_SETLK或F_SETLKW）。

    重要结构体：
    struct flock{
    short l_type;  // F_RDLCK读锁，F_WRLCK写锁，F_UNLCK解锁
    off_t l_start; // 锁偏移的字节
    short l_whence;// 锁开始的位置，SEEK_SET,SEEK_CURorSEEK_END
    off_t l_len;   // 锁的范围，为0表示从起始到文件末
    pid_t l_pid;   // 放入具有能阻塞当前进程的锁(仅由F_GETLK返回)
    };
    
    
    有以下几点需要强调：
    1. l_start 是相对 l_whence 的偏移量，合起来表示锁起始处，单位是字节。可以是文件尾端处或更后，但不可是文件初始之前。

　　2. l_len 单位是字节，当是具体数字时是正整数，0时表示从起始位置到文件末尾。0时就表示之后在解锁前加入的内容都在锁区域。

　  3. 通常对通篇文件上锁的参数是 l_start = 0; l_whence = SEEK_SET ; l_len = 0;

    1 //给文件整体上锁
    2 int lockfile(int fd)
    3 {
    4     struct flock fl;
    5     fl.l_type = F_WRLCK;
    6     fl.l_start = 0;
    7     fl.l_whence = SEEK_SET;
    8     fl.l_len = 0;
    9     return (fcntl(fd,F_SETLK,&fl));
    10 }
}

文件锁的基本概念
{
    1.当多个用户需要共享一个文件时，Linux通常采用的方法是给文件上锁，来避免共享的资源产生竞争的状态。
    
    2.建议性锁：要求每个使用上锁文件的进程都要检查是否有锁存在，并且尊重已有的锁。在一般情况下，内核和系统都不使用建议性锁，它们依靠程序员遵守这个规定。
    
    3.强制性锁：是由内核执行的锁，当一个文件被上锁进行写入操作的时候，内核将阻止其他任何文件对其进行读写操作。采用强制性锁对性能的影响很大，每次读写操作都必须检查是否有锁存在。
    
    4.在Linux中，实现文件上锁的函数有lockf()和fcntl()
    
    5.lockf()用于对文件施加建议性锁
    
    6.fcntl()不仅可以施加建议性锁，还可以施加强制锁
    
    7.fcntl()还能对文件的某一记录上锁，也就是记录锁。
    
    8.记录锁又可分为读取锁和写入锁，其中读取锁又称为共享锁，它能够使多个进程都能在文件的同一部分建立读取锁。
    
    9.写入锁又称为排斥锁，在任何时刻只能有一个进程在文件的某个部分建立写入锁。
    
    10.在文件的同一部分不能同时建立读取锁和写入。
}

C++日志宏dingy
{
    1.时间，日志等级，源码文件，源码行数，日志字符串格式化内容。
    2.LOG_ERR("check file failed, task id = %d, error = %d", iTaskID, iErrCode);
    3.[2017-10-28 19:40:01][ERROR][uploadclient.cpp][380] check file failed, task id = 6, error = 23
}

static RosCommunication* instance(std::string ns = "");
{
    1.通过静态的类方法（getInstance) 获取instance，该方法是静态方法，instance由该方法返回（被该方法使用），如果instance非静态，无法被getInstance调用；
    2.instance需要在调用getInstance时候被初始化，只有static的成员才能在没有创建对象时进行初始化。且类的静态成员在类第一次被使用时初始化后就不会再被初始化，保证了单例。
    3.static类型的instance存在静态存储区，每次调用时，都指向的同一个对象。
}

std::function的用法
{
    1.介绍： std::function是一个可调用对象包装器，是一个类模板，可以容纳所有可调用对象，它可以用统一的方式处理函数、函数对象、函数指针，并允许保存和延迟它们的执行。

    2.头文件：#include <functional>

    3.定义格式： std::function<函数类型>
    
    4.因为std::function是一种模板，所以要传入类型，将其当做std::vector<>这样的模板， 像std::vector<int>传入类型int一样，std::function传入的是函数类型<返回值 （参数类型）>，如：std::function<void (int)>。

    5.作用： std::function可以取代函数指针的作用，因为它可以延迟函数的执行，特别适合作为回调函数使用。它比普通函数指针更加的灵活和便利。
    
    6.std::function可以绑定到全局函数/类静态成员函数(类静态成员函数与全局函数没有区别)
}

扩展链接