std.h函数说明
-std=c++11-std=gnu++11c++0xc++11
-std=c++11-std=gnu++11c++0xc++11uint8_t的后缀_t的意思到底表⽰什么？它就是⼀个结构的标注，可以理解为type/typedef的缩写，表⽰它是通过typedef定义的，⽽不是其它数据类型。
uint8_t，uint16_t，uint32_t等都不是什么新的数据类型，它们只是使⽤typedef给类型起的别名，新瓶装⽼酒的把戏。
不过，不要⼩看了typedef，它对于你代码的维护会有很好的作⽤。
⽐如C中没有bool，于是在⼀个软件中，⼀些程序员使⽤int，⼀些程序员使⽤ short，会⽐较混乱，最好就是⽤⼀个typedef来定义，如：typedef char bool;c++1z就是c++17-std=c++11，⽀持C++11标准；-std=gnu++11，⽀持C++11标准和GNU扩展特性；C++17 is not supported by GCC v4.8.C++17 is not supported by GCC v4.9.C++17 is supported by , but you need -std=c++1zC++17 is supported by GCC v8 by means of -std=c++17 (and by -std=c++1z which is deprecated since then).For the GNU-C++ dialects, use -std=gnu++* instead of -std=c++*.CMAKE_CXX_COMPILER_IDThe old -std=c++0x is only needed for older compiler versions that did not support -std=c++11 and they chose that name to express the preliminary and unstable nature of features (and the ABI) of the then upcoming C++11 (and when it was still unclear whether that would eventually become C++10 or C++12). They changes some of the details adapting to the changing working drafts of the standard at the time before the C++11 standard was officially released.If your compiler supports -std=c++11, there is no reason to use -std=c++0x. Concerning compatibility: There might even be differences and incompatibilities, but these are not just bound to the use of -std=c++0x, but to specific versions of the compiler. When the compiler supports both, they should be identical.⾖瓣：上⼀个版本的C++国际标准是2003年发布的，所以叫C++ 03。
c++中实现调用外部程序的方法linux__概述及解释说明
c++中实现调用外部程序的方法linux 概述及解释说明1. 引言1.1 概述本篇文章旨在探讨在C++语言中如何调用外部程序，并着重介绍在Linux环境下的具体方法。
调用外部程序是在软件开发中常见的需求，通过调用外部程序可以实现更多功能和交互方式。
本文将从基本原理以及注意事项开始阐述，然后详细介绍在C++中实现调用外部程序的方法，并给出示例代码进行解析。
1.2 文章结构本文将按照以下结构组织内容：首先，在引言部分进行概述和明确目的；然后在第2节中，详细讲解在C++中调用外部程序的方法，包括基本原理和Linux环境下的注意事项；紧接着，在第3节中，将通过示例及代码解析展示具体的调用外部程序的实现过程；最后，在第4节中，介绍使用第三方库实现更复杂交互方式的方法，并给出相关示例；最后一节为结论与总结。
1.3 目的本文旨在提供读者关于C++语言中如何通过调用外部程序来扩展功能和实现更灵活交互方式方面的详尽解释。
通过了解基本原理以及学习具体实践案例，读者可获得掌握在C++中调用外部程序的能力。
另外，引入第三方库实现更复杂交互方式的方法也将拓宽读者的知识面和技能应用范围。
最终，通过全面而清晰地阐述调用外部程序的方法，本文旨在提供有关调用外部程序的详尽指南，并启示读者对未来可能发展方向的展望。
以上是关于文章“1. 引言”部分内容的详细说明。
2. 调用外部程序的方法:在C++中，调用外部程序是一种常见的需求，可以通过多种方式实现。
本节将介绍C++中调用外部程序的基本原理、在Linux环境下调用外部程序时需要注意的事项以及具体的实现方法介绍。
2.1 C++中调用外部程序的基本原理:在C++中，调用外部程序可以借助操作系统提供的系统调用或库函数来实现。
常见的方法包括使用system函数、使用fork和exec函数族以及使用popen 函数等。
2.2 Linux环境下调用外部程序的注意事项:在Linux环境下调用外部程序时，需要注意以下几个方面：- 文件路径：确保正确地指定待执行的外部程序文件路径，在使用相对路径时要考虑当前工作目录。
C标准库源码解剖(4)：字符串处理函数string.h和wchar.h
C标准库源码解剖(4)：字符串处理函数string.h和wchar.h简要介绍资料的主要内容,以获得更多的关注C标准库源码解剖(4)：字符串处理函数string.h和wchar.h分类：C 20XX年-10-08 12:39 648人阅读评论(1) 收藏举报string.h中包含了所有的字符串处理函数，也包含了内存处理函数，因为这些内存处理函数（如比如、复制、搜索）的功能与字符串处理函数功能类似。
我们是用通用指针来指向内存块的，通用指针可以用char*类型（传统C语言），也可以用void*类型（标准C语言）。
每个函数都有对应的宽字符版本，在wchar.h中。
string.h中包含的标准库函数：strcat,strncat,strcmp,strncmp,strcpy,strncpy,strlen,strchr,strrchr,strspn,strcsp n,strpbrk, strstr,strok,strcoll,strxfrm,strerror;memcpy,memmove,memcmp,memchr,memeset。
GNU还提供了很多非标准的扩展，如memccpy,rawmemchr,memrchr, strdup,strndup等。
view plaincopy to clipboardprint? 1. /* ISO C99 Standard: 7.21 字符串处理string.h */2. #ifndef _STRING_H3. #define _STRING_H 14. #include features.h /* 非标准头文件，定义了一些编译选项*/5. __BEGIN_DECLS6. /* 从stddef.h中获得size_t和NULL */7. #define __need_size_t8. #define __need_NULL9. #include stddef.h10. __BEGIN_*****CE_STD11. /* 从SRC中复制N个字节的内容到DEST中*/12. extern void *memcpy (void *__restrict __dest,13. __const void *__restrict __src, size_t __n)14. __THROW __nonnull ((1, 2));15. /* 从SRC中复制N个字节的内容到DEST中，保证对重叠字符串（即SRC与DEST共用存储空间）有正确的行为*/16. extern void *memmove (void *__dest, __const void *__src, size_t __n)17. __THROW __nonnull ((1, 2));18. __END_*****CE_STD19. /* 从SRC中复制不超过N个字节的内容到DEST中，当遇到字符C返回DEST中C的拷贝后面的字符指针。
linux下的stdin,stdout,stderr
用户操作Linux 下stdin stdout stderr 的由来收藏现在就从linux kernel的源代码的角度来分析该。
二:fork()与execve()中stderr,stdio.stdout的继承关系其实用继承这个词好像不太准确,要准确一点,可能复制更适合.首先有二点:1:父进程fork出子进程后,是共享所有文件描述符的(实际上也包括socket)2:进程在execve后,除了用O_CLOEXEC标志打开的文件外,其它的文件描述符都是会复制到下个执行序列(注意这里不会产生一个新进程,只是将旧的进程替换了)下面我们从代码中找依据来论证以上的两个观点.对于第一点:我们在分析进程创建的时候,已经说过,如果父过程在创建子进程的时候带了CLONE_FILE S标志的时候,会和父进程共享task->files.如果没有定义,就会复制父进程的task->files.无论是哪种情况,父子进程的环境都是相同的.代码如下:static int copy_files(unsigned long clone_flags, struct task_struct * tsk) {struct files_struct *oldf, *newf;int error = 0;oldf = current->files;if (!oldf)goto out;if (clone_flags & CLONE_FILES) {atomic_inc(&oldf->count);goto out;}tsk->files = NULL;newf = dup_fd(oldf, &error);if (!newf)goto out;tsk->files = newf;error = 0;out:return error;}从上面的代码可以看出.如果带CLONE_FILES标志,只是会增加它的引用计数.否则,打开的文件描符述会全部复制.对于二:我们之前同样也分析过sys_execve().如果有不太熟悉的,到本站找到相关文章进行阅读.在这里不再详细说明整个流程.相关代码如下:static void flush_old_files(struct files_struct * files){long j = -1;struct fdtable *fdt;spin_lock(&files->file_lock);for (;;) {unsigned long set, i;j++;i = j * __NFDBITS;fdt = files_fdtable(files);if (i >= fdt->max_fds)break;set = fdt->close_on_exec->fds_bits[j];if (!set)continue;fdt->close_on_exec->fds_bits[j] = 0;spin_unlock(&files->file_lock);for ( ; set ; i++,set >>= 1) {if (set & 1) {sys_close(i);}}spin_lock(&files->file_lock);}spin_unlock(&files->file_lock);}该函数会将刷新旧环境的文件描述符信息.如果该文件描述符在fdt->close_on_exec被置位,就将其关闭.然后,我们来跟踪一下,在什么样的情况下,才会将fdt->close_on_exec的相关位置1. 在sys_open() àget_unused_fd_flags():int get_unused_fd_flags(int flags){………….if (flags & O_CLOEXEC)FD_SET(fd, fdt->close_on_exec);elseFD_CLR(fd, fdt->close_on_exec);……}只有在带O_CLOEXEC打开的文件描述符,才会在execve()中被关闭.三:用户空间的stderr,stdio.stdout初始化论证完上面的二个观点之后,后面的就很容易分析了.我们先来分析一下,在用户空间中,prin tf是可以使用的.哪它的stderr,stdio.stdout到底是从哪点来的呢?我们知道,用户空间的所有进程都是从init进程fork出来的.因此,它都是继承了init进程的相关文件描述符.因此,问题都落在,init进程的stderr,stdio.stdout是在何时被设置的?首先,我们来看一下内核中的第一个进程.它所代码的task_struct结构如下所示:#define INIT_TASK(tsk){.state = 0,.stack = &init_thread_info,.usage = ATOMIC_INIT(2),.flags = 0,.lock_depth = -1,.prio = MAX_PRIO-20,.static_prio = MAX_PRIO-20,.normal_prio = MAX_PRIO-20,.policy = SCHED_NORMAL,.cpus_allowed = CPU_MASK_ALL,……..files = &init_files,……}它所有的文件描述符信息都是在init_files中的,定义如下:static struct files_struct init_files = INIT_FILES;#define INIT_FILES{.count = ATOMIC_INIT(1),.fdt = &init_files.fdtab,.fdtab = INIT_FDTABLE,.file_lock = __SPIN_LOCK_UNLOCKED(init_task.file_lock),.next_fd = 0,.close_on_exec_init = { { 0, } },.open_fds_init = { { 0, } },.fd_array = { NULL, }}我们从这里可以看到,内核的第一进程是没有带打开文件信息的.我们来看一下用户空间的init进程的创建过程:Start_kernel() -àrest_init()中代码片段如下:static void noinline __init_refok rest_init(void)__releases(kernel_lock){int pid;kernel_thread(kernel_init, NULL, CLONE_FS | CLONE_SIGHAND);numa_default_policy();pid = kernel_thread(kthreadd, NULL, CLONE_FS | CLONE_FILES);kthreadd_task = find_task_by_pid(pid);unlock_kernel();/** The boot idle thread must execute schedule()* at least once to get things moving:*/init_idle_bootup_task(current);preempt_enable_no_resched();schedule();preempt_disable();/* Call into cpu_idle with preempt disabled */cpu_idle();}该函数创建了两个进程,然后本进程将做为idle进程在轮转.在创建kernel_init进程的时候,带的参数是CLONE_FS | CLONE_SIGHAND.它没有携带CLONE_FILES标志.也就是说,kernel_init中的文件描述符信息是从内核第一进程中复制过去的.并不和它共享.以后,kernel_init进程中,任何关于files的打开,都不会影响到父进程.然后在kernel_init() àinit_post()中有:static int noinline init_post(void){ …………if (sys_open((const char __user *) "/dev/console", O_RDWR, 0) < 0)printk(KERN_WARNING "Warning: unable to open an initial co nsole.\n");(void) sys_dup(0);(void) sys_dup(0);…………run_init_process(XXXX);}从上面的代码中可以看到,它先open了/dev/console.在open的时候,会去找进程没使用的最小文件序号.而,当前进程没有打开任何文件,所以sys_open()的时候肯定会找到0.然后,两次调用sys_dup(0)来复制文件描述符0.复制后的文件找述符肯定是1.2.这样,0.1.2就建立起来了.然后这个进程调用run_init_process() àkernel_execve()将当前进程替换成了用户空间的一个进程,这也就是用户空间init进程的由来.此后,用户空间的进程全是它的子孙进程.也就共享了这个0.1.2的文件描述符了.这也就是我们所说的stderr.stdio,stdout.从用户空间写个程序测试一下:#include <stdio.h>#include <stdlib.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>main(){int ret;char *ttyname0,*ttyname1,*ttyname2;ttyname0 = ttyname(0);ttyname1 = ttyname(1);ttyname2 = ttyname(2);printf(“file0 : %s\n”,ttyname0);printf(“file1 : %s\n”,ttyname1);printf(“file2 : %s\n”,ttyname2);return;}运行这个程序,我们会看到,0,1,2描述符的信息全为/dev/consle.四:内核创建用户空间进程的过程在内核中创建用户空间进程的相应接口为call_usermodehelper().实现上,它将要创建的进程信息链入一个工作队列中,然后由工作队列处理函数调用kernel _thread()创建一个子进程,然后在这个进程里调用kernel_execve()来创建用户空间进程.在这里要注意工作队列和下半部机制的差别.工作队列是利用一个内核进程来完成工作的,它和下半部无关.也就是说,它并不在一个中断环境中.那就是说,这样创建出来的进程,其实就是内核环境,它没有打开0,1.2的文件描述符.可能也有人会这么说:那我就不在内核环境下创建用户进程不就行了?例如,我在init_module的时候,创建一个内核线程,然后在这个内核线程里,kernel_execv e()一个用户空间进程不就可以了吗?的确,在这样的情况下,创建的进程不是一个内核环境,因为在调用init_module()的时候,已经通过系统调用进入kernel,这时的环境是对应用户进程环境.但是别忘了.在系统调用环境下,再进行系统调用是不会成功的(kernel_execve也对应一个系统调用.)举例印证如下:Mdoule代码:#include <linux/ioport.h>#include <linux/interrupt.h>#include <asm/io.h>#include <linux/serial_core.h>#include <linux/kmod.h>#include <linux/file.h>#include <linux/unistd.h>MODULE_LICENSE("GPL");MODULE_AUTHOR( "ericxiao:xgr178@" );static int exeuser_init(){int ret;char *argv[] ={"/mnt/hgfs/vm_share/user_test/main",NULL,};char *env[] ={"HOME=/","PATH=/sbin:/bin:/usr/sbin:/usr/bin",NULL,};printk("exeuser_init ...\n");ret = call_usermodehelper(argv[0], argv, env,UMH_WAIT_EXEC);return 0;}static int exeuser_exit(){printk("exeuser_exit ...\n");return 0;}module_init(exeuser_init);module_exit(exeuser_exit);用户空间程序代码:#include <stdio.h>#include <stdlib.h>#include <unistd.h>#include <sys/types.h>#include <sys/stat.h>#include <fcntl.h>int main(int argc,char *argv[],char *env[]){int i;int fd;int size;char *tty;FILE *confd;char printfmt[4012];system("echo i am coming > /var/console");for(i=0; env[i]!=NULL;i++){sprintf(printfmt,"echo env[%d]:%s. >>/var/console",i,env[i]);system(printfmt);}for(i=0; i<argc ;i++){sprintf(printfmt,"echo arg[%d]:%s. >>/var/console",i,argv[i]);system(printfmt);}tty = ttyname(0);if(tty == NULL)system("echo tty0 is NULL >> /var/console");else{sprintf(printfmt,"echo ttyname0 %s. >>/var/console",tty);system(printfmt);}tty = ttyname(1);if(tty == NULL)system("echo tty1 is NULL >> /var/console");else{sprintf(printfmt,"echo ttyname1 %s. >>/var/console",tty);system(printfmt);}tty = ttyname(2);if(tty == NULL)system("echo tty2 is NULL >> /var/console");else{sprintf(printfmt,"echo ttyname2 %s. >>/var/console",tty);system(printfmt);}tty = ttyname(fd);if(tty == NULL)system("echo fd is NULL >> /var/console");else{sprintf(printfmt,"echo fd %s. >>/var/console",tty);system(printfmt);}return 0;}插入模块过后,调用用户空间的程序,然后这个程序将进程环境输出到/var/console中,完了可以看到.这个进程输出的0,1,2描述符信息全部NULL.千万要注意,在测试的用户空间程序,不能打开文件.这样会破坏该进程的原始文件描述符环境(因为这个问题.狠调了一个晚上,汗颜…).这样.用户空间的printf当然就不能打印出东西了.ps：这位老兄的帖子解了我的一些疑惑。
C++的iostream标准库介绍以及对左移与右移运算符的重载
我们从一开始就一直在利用C++的输入输出在做着各种练习,输入输出是由iostream库提供的,所以讨论此标准库是有必要的,它与C语言的stdio库不同,它从一开始就是用多重继承与虚拟继承实现的面向对象的层次结构,作为一个c++的标准库组件提供给程序员使用。
iostream为内置类型类型对象提供了输入输出支持,同时也支持文件的输入输出,类的设计者可以通过对iostream库的扩展,来支持自定义类型的输入输出操作。
为什么说要扩展才能提供支持呢?我们来一个示例。
C++ 代码#include#include <iostream>using namespace std;class Test{public:Test(int a=0,int b=0){Test::a=a;Test::b=b;}int a;int b;};int main(){Test t(100,50);printf("%???",t);//不明确的输出格式scanf("%???",t);//不明确的输入格式cout<//同样不够明确cin>>t;//同样不够明确system("pause");}由于自定义类的特殊性,在上面的代码中,无论你使用c风格的输入输出,或者是c++的输入输出都不是不明确的一个表示,由于c语言没有运算符重载机制,导致stdio库的不可扩充性,让我们无法让printf()和scanf()支持对自定义类对象的扩充识别,而c++是可以通过运算符重载机制扩充iostream库的,使系统能能够识别自定义类型,从而让输入输出明确的知道他们该干什么,格式是什么。
在上例中我们之所以用printf与cout进行对比目的是为了告诉大家,C与C++处理输入输出的根本不同,我们从c远的输入输出可以很明显看出是函数调用方式,而c++的则是对象模式,cout和cin是ostream类和istream类的对象。
C++ using std namespace 详解
using namespace std是什么意思1）命名空间的意思！2）#include <iostream.h>等同于：#include <iostream>using namespace std;具体点：std::cout , std::endl; (在没有.h 或者using namespace std 情况下) cout , endl (在有.h 或者using namespace std)3）意思"使用std(标准)名字空间"的意思;假若你包含了标准库的头文件(如:cmath,cassert,vector等),而你又不想在使用std名字空间任何东西时加上"std::" 前缀,你就可以用using 关键字来向编译器说明你将要引用哪个名字空间下的东西. 一旦出现了"using namespace std;"这一句,那么在该行所在的作用域内有效,不过你还可以用"作用域分辩符'::'"来引用全局的函数或变量类型.4）使用名字空间。
使用名字空间是为了避免类名字的污染，这是因为你有可能会命名一些有相同类名但实际操作不太相同的类，如果放在一起，编译器就不知道到底该用谁，如果你把具有相同类名的类放在不同的名字空间里，调用时注明是哪个名字空间里的类，编译器就能清楚了。
详细内容建议看看《c++ primer》5）表示用的是标准名字空间std表示你所使用的一些函数，标准的对象（如cout）都是在名字空间std 下面的6）所谓的名字空间是标准c++中的一种机制，用来控制不同类库的冲突问题。
使用它可以在不同的空间内使用同名字的类或者函数！如下std::cout<<"hi"; //表示使用std名字空间中的cout而不是普通的cout;如果用using namespace std;就可以去掉“std::“而表示使用标准std空间中的函数（加上后缺省使用std空间中的）std当然不是随便的，它是标准的！当然你可以自己做，那个时候就是任意的了。
几个有关函数
bsearch在一批数据里查找某个项：
void *bsearch(const void *key, const void *base, size_t n, size_t size, int (*cmp)(const void *keyval, const void *datum) )
cmp应与strcmp类似，在数keyval与datum相 比更大/相等/更小时分别返回正/零/负值。 设数组base[0]..base[n-1]元素按cmp序上 升排列，元素大小为size。bsearch以*key为 比较依据在数组里查找匹配元素（使cmp值等于 0的元素），返回指向该元素的指针。找不到时 返回NULL。
出错处理
输出出错信息是希望显示到屏幕供人读。通过stdout 不合适：输出定向到文件也使出错信息送到文件。
送到标准错误流stderr的信息不受定向影响。改造前 面程序cat，只需要改动一个语句：
fprintf(stderr,"%s, can't open in file: %s\n", name, *argv);
函数bsearch和qsort使用的一个例子： int *p, k = 7; int a[] = {5, 6, 3, 28, 23, 34, 7, 9, 6, 14};
int icmp (const void *p, const void *q) { int *m =(int*)p, *n =(int*)q; return *n>*m ? 1 : (*n==*m ? 0 : -1); }
9.5.3 关于日期和时间的函数，<time.h>
定义了几个时间类型，说明了许多函数。time_t和 clock_t是表示时间的数值类型：clock_t表示计时 时间；time_t表示某种日历时间，从历史的某时刻开 始计算。定义了时间结构struct tm，成分： int tm_sec; 剩余秒数（0～61） int tm_min; 剩余分钟数（0～59） int tm_hour; 剩余小时数（0～23） int tm_mday; 月中日数（1～31） int tm_mon; 年中月数（1～12） int tm_year; 1900后的年序数 int tm_wday; 星期中日序数（0～6） int tm_isday; 夏季时标志 int tm_yday; 年中日序数（0～365）
C++关键字及说明解释
C++关键词asmautobad_castbad_typeidboolbreakcasecatchcharclassconstconst_castcontinuedefaultdeletedodoubledynamic_cast elseenumexcept explicit externfalsefinallyfloatforfriendgotoifinlineintlongmutable namespaceoperator private protected publicregister reinterpret_cast returnshortsignedsizeofstaticstatic_caststructswitch templatethistruetrytype_infotypedeftypeid typename unionunsignedusingvirtualvoidvolatilewchar_t whileasm已经被__asm替代了,用于汇编语言嵌入在C/C++程序里编程,从而在某些方面优化代码.虽然用asm关键词编译时编译器不会报错,但是asm模块的代码是没有意义的.(2)auto这个这个关键词用于声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。
这个关键词不怎么多写，因为所有的变量默认就是auto的。
(3)bad_cast,const_cast,dynamic_cast,reinterpret_cast,static_cast关于异常处理的,还不是太了解..(4)bad_typeid也是用于异常处理的,当typeid操作符的操作数typeid为Null指针时抛出.(5)bool不用多说了吧,声明布尔类型的变量或函数.(6)break跳出当前循环.The break statement terminates the execution of the nearest enclosing loop or conditional statement in which it appears.(7)caseswitch语句分支.Labels that appear after the case keyword cannot also appear outside a switch statement.(8)catch,throw,try都是异常处理的语句,The try, throw, and catch statements implement exception handling.(9)char声明字符型变量或函数.(10)class声明或定义类或者类的对象.The class keyword declares a class type or defines an object of a class type.(11)const被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。
通达信指标函数说明大全
通达信指标函数说明大全通达信指标函数是通达信软件中用于计算和显示各种技术指标的函数。
这些函数涵盖了技术分析中常用的各类指标，比如移动平均线、相对强弱指标、动量指标、布林带等。
下面是针对通达信中的常用指标函数进行的详细说明。
1.移动平均线类指标函数：-MA(X,N)：计算X收盘价在N周期内的简单移动平均线。
其中，X是移动平均线的参数，N是移动平均的周期。
-EMA(X,N)：计算X收盘价在N周期内的指数移动平均线。
其中，X是指数移动平均线的参数，N是指数移动平均的周期。
-AMA(C,N,M)：计算C收盘价在N周期内的自适应移动平均线。
其中，C是自适应移动平均线的收盘价，N是移动平均周期，M是影响因素。
2.相对强弱指标类函数：-RSI(C,N)：计算C收盘价在N周期内的相对强弱指标。
其中，C是收盘价，N是相对强弱指标的周期。
-WR(L,H,N)：计算L最低价和H最高价在N周期内的威廉指标。
其中，L是最低价，H是最高价，N是威廉指标的周期。
-CR(A1,B1,C1,N,M)：计算A1最高价、B1最低价、C1收盘价在N周期内的相对强弱指标。
其中，A1是最高价，B1是最低价，C1是收盘价，N是相对强弱指标的周期，M是计算中的影响因素。
3.动量指标类函数：-ROC(C,N)：计算C收盘价在N周期内的变动率指标。
其中，C是收盘价，N是变动率指标的周期。
-CC(C,N)：计算C收盘价在N周期内的变动量指标。
其中，C是收盘价，N是变动量指标的周期。
-BBI(C,N1,N2,N3,N4)：计算C收盘价在N1、N2、N3、N4周期内的多空指标。
其中，C是收盘价，N1、N2、N3、N4是多空指标的周期。
4.布林带类函数：-BOLL(C,N,P)：计算C收盘价在N周期内的布林带指标。
其中，C是收盘价，N是布林带指标的周期，P是布林带的偏差比率。
-STD(C,N)：计算C收盘价在N周期内的标准差指标。
其中，C是收盘价，N是标准差指标的周期。
#stdib.h的用法
stdlib.hstdlib 头文件里包含了C、C++语言的一些函数该文件包含了的C语言标准库函数的定义stdlib.h里面定义了五种类型、一些宏和通用工具函数。
类型例如size_t、wch ar_t、div_t、ldiv_t和lldiv_t；宏例如EXIT_FAILURE、EXIT_SUCCESS、RAND_ MAX和MB_CUR_MAX等等；常用的函数如malloc()、calloc()、realloc()、free()、system()、atoi()、atol()、rand()、srand()、exit()等等。
具体的内容你自己可以打开编译器的include目录里面的stdlib.h头文件看看。
stdlib.h内容如下：/****stdlib.h - declarations/definitions for commonly used library functions** Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.**Purpose:* This include file contains the function declarations for commonly* used library functions which either don't fit somewhere else, or,* cannot be declared in the normal place for other reasons.* [ANSI]** [Public]*****/#if _MSC_VER > 1000#pragma once#endif#ifndef _INC_STDLIB#define _INC_STDLIB#if !defined(_WIN32) && !defined(_MAC)#error ERROR: Only Mac or Win32 targets supported!#endif#ifdef _MSC_VER/** Currently, all MS C compilers for Win32 platforms default to 8 byte* alignment.*/#pragma pack(push,8)#endif /* _MSC_VER */#ifdef __cplusplusextern "C" {#endif/* Define _CRTIMP */#ifndef _CRTIMP#ifdef _DLL#define _CRTIMP __declspec(dllimport)#else /* ndef _DLL */#define _CRTIMP#endif /* _DLL */#endif /* _CRTIMP *//* Define __cdecl for non-Microsoft compilers */#if ( !defined(_MSC_VER) && !defined(__cdecl) )#define __cdecl#endif/* Define _CRTAPI1 (for compatibility with the NT SDK) */ #ifndef _CRTAPI1#if _MSC_VER >= 800 && _M_IX86 >= 300#define _CRTAPI1 __cdecl#else#define _CRTAPI1#endif#endif#ifndef _SIZE_T_DEFINEDtypedef unsigned int size_t;#define _SIZE_T_DEFINED#endif#ifndef _WCHAR_T_DEFINEDtypedef unsigned short wchar_t;#define _WCHAR_T_DEFINED#endif/* Define NULL pointer value */#ifndef NULL#ifdef __cplusplus#define NULL 0#else#define NULL ((void *)0)#endif#endif/* Definition of the argument values for the exit() function */#define EXIT_SUCCESS 0#define EXIT_FAILURE 1#ifndef _ONEXIT_T_DEFINEDtypedef int (__cdecl * _onexit_t)(void);#if !__STDC__/* Non-ANSI name for compatibility */#define onexit_t _onexit_t#endif#define _ONEXIT_T_DEFINED#endif/* Data structure definitions for div and ldiv runtimes. */#ifndef _DIV_T_DEFINEDtypedef struct _div_t {int quot;int rem;} div_t;typedef struct _ldiv_t {long quot;long rem;} ldiv_t;#define _DIV_T_DEFINED#endif/* Maximum value that can be returned by the rand function. */#define RAND_MAX 0x7fff/** Maximum number of bytes in multi-byte character in the current locale * (also defined in ctype.h).*/#ifndef MB_CUR_MAX#define MB_CUR_MAX __mb_cur_max_CRTIMP extern int __mb_cur_max;#endif /* MB_CUR_MAX *//* Minimum and maximum macros */#define __max(a,b) (((a) > (b)) ? (a) : (b))#define __min(a,b) (((a) < (b)) ? (a) : (b))/** Sizes for buffers used by the _makepath() and _splitpath() functions. * note that the sizes include space for 0-terminator*/#ifndef _MAC#define _MAX_PATH 260 /* max. length of full pathname */#define _MAX_DRIVE 3 /* max. length of drive component */#define _MAX_DIR 256 /* max. length of path component */#define _MAX_FNAME 256 /* max. length of file name component */ #define _MAX_EXT 256 /* max. length of extension component */#else /* def _MAC */#define _MAX_PATH 256 /* max. length of full pathname */#define _MAX_DIR 32 /* max. length of path component */#define _MAX_FNAME 64 /* max. length of file name component */#endif /* _MAC *//** Argument values for _set_error_mode().*/#define _OUT_TO_DEFAULT 0#define _OUT_TO_STDERR 1#define _OUT_TO_MSGBOX 2#define _REPORT_ERRMODE 3/* External variable declarations */#if (defined(_MT) || defined(_DLL)) && !defined(_MAC)_CRTIMP int * __cdecl _errno(void);_CRTIMP unsigned long * __cdecl __doserrno(void);#define errno (*_errno())#define _doserrno (*__doserrno())#else /* ndef _MT && ndef _DLL */_CRTIMP extern int errno; /* XENIX style error number */_CRTIMP extern unsigned long _doserrno; /* OS system error value */ #endif /* _MT || _DLL */#ifdef _MAC_CRTIMP extern int _macerrno; /* OS system error value */#endif_CRTIMP extern char * _sys_errlist[]; /* perror error message table */ _CRTIMP extern int _sys_nerr; /* # of entries in sys_errlist table */#if defined(_DLL) && defined(_M_IX86)#define __argc (*__p___argc()) /* count of cmd line args */#define __argv (*__p___argv()) /* pointer to table of cmd line args */ #define __wargv (*__p___wargv()) /* pointer to table of wide cmd line ar gs */#define _environ (*__p__environ()) /* pointer to environment table */#ifdef _POSIX_extern char ** environ; /* pointer to environment table */#else#ifndef _MAC#define _wenviron (*__p__wenviron()) /* pointer to wide environment tabl e */#endif /* ndef _MAC */#endif /* _POSIX_ */#define _pgmptr (*__p__pgmptr()) /* points to the module (EXE) name */ #ifndef _MAC#define _wpgmptr (*__p__wpgmptr()) /* points to the module (EXE) wide name */#endif /* ndef _MAC */_CRTIMP int * __cdecl __p___argc(void);_CRTIMP char *** __cdecl __p___argv(void);_CRTIMP wchar_t *** __cdecl __p___wargv(void);_CRTIMP char *** __cdecl __p__environ(void);_CRTIMP wchar_t *** __cdecl __p__wenviron(void);_CRTIMP char ** __cdecl __p__pgmptr(void);_CRTIMP wchar_t ** __cdecl __p__wpgmptr(void);#else_CRTIMP extern int __argc; /* count of cmd line args */_CRTIMP extern char ** __argv; /* pointer to table of cmd line args */ #ifndef _MAC_CRTIMP extern wchar_t ** __wargv; /* pointer to table of wide cmd lin e args */#endif /* ndef _MAC */#ifdef _POSIX_extern char ** environ; /* pointer to environment table */#else_CRTIMP extern char ** _environ; /* pointer to environment table */#ifndef _MAC_CRTIMP extern wchar_t ** _wenviron; /* pointer to wide environment ta ble */#endif /* ndef _MAC */#endif /* _POSIX_ */_CRTIMP extern char * _pgmptr; /* points to the module (EXE) name */ #ifndef _MAC_CRTIMP extern wchar_t * _wpgmptr; /* points to the module (EXE) wid e name */#endif /* ndef _MAC */#endif_CRTIMP extern int _fmode; /* default file translation mode */_CRTIMP extern int _fileinfo; /* open file info mode (for spawn) *//* Windows major/minor and O.S. version numbers */_CRTIMP extern unsigned int _osver;_CRTIMP extern unsigned int _winver;_CRTIMP extern unsigned int _winmajor;_CRTIMP extern unsigned int _winminor;/* function prototypes */#if _MSC_VER >= 1200_CRTIMP __declspec(noreturn) void __cdecl abort(void);_CRTIMP __declspec(noreturn) void __cdecl exit(int);#else_CRTIMP void __cdecl abort(void);_CRTIMP void __cdecl exit(int);#endif#if defined(_M_MRX000)_CRTIMP int __cdecl abs(int);#elseint __cdecl abs(int);#endifint __cdecl atexit(void (__cdecl *)(void));_CRTIMP double __cdecl atof(const char *);_CRTIMP int __cdecl atoi(const char *);_CRTIMP long __cdecl atol(const char *);#ifdef _M_M68K_CRTIMP long double __cdecl _atold(const char *);#endif_CRTIMP void * __cdecl bsearch(const void *, const void *, size_t, size _t,int (__cdecl *)(const void *, const void *));_CRTIMP void * __cdecl calloc(size_t, size_t);_CRTIMP div_t __cdecl div(int, int);_CRTIMP void __cdecl free(void *);_CRTIMP char * __cdecl getenv(const char *);_CRTIMP char * __cdecl _itoa(int, char *, int);#if _INTEGRAL_MAX_BITS >= 64_CRTIMP char * __cdecl _i64toa(__int64, char *, int);_CRTIMP char * __cdecl _ui64toa(unsigned __int64, char *, int);_CRTIMP __int64 __cdecl _atoi64(const char *);#endif#if defined(_M_MRX000)_CRTIMP long __cdecl labs(long);#elselong __cdecl labs(long);#endif_CRTIMP ldiv_t __cdecl ldiv(long, long);_CRTIMP char * __cdecl _ltoa(long, char *, int);_CRTIMP void * __cdecl malloc(size_t);_CRTIMP int __cdecl mblen(const char *, size_t);_CRTIMP size_t __cdecl _mbstrlen(const char *s);_CRTIMP int __cdecl mbtowc(wchar_t *, const char *, size_t);_CRTIMP size_t __cdecl mbstowcs(wchar_t *, const char *, size_t); _CRTIMP void __cdecl qsort(void *, size_t, size_t, int (__cdecl *) (const void *, const void *));_CRTIMP int __cdecl rand(void);_CRTIMP void * __cdecl realloc(void *, size_t);_CRTIMP int __cdecl _set_error_mode(int);_CRTIMP void __cdecl srand(unsigned int);_CRTIMP double __cdecl strtod(const char *, char **);_CRTIMP long __cdecl strtol(const char *, char **, int);#ifdef _M_M68K_CRTIMP long double __cdecl _strtold(const char *, char **);#endif_CRTIMP unsigned long __cdecl strtoul(const char *, char **, int); #ifndef _MAC_CRTIMP int __cdecl system(const char *);#endif_CRTIMP char * __cdecl _ultoa(unsigned long, char *, int);_CRTIMP int __cdecl wctomb(char *, wchar_t);_CRTIMP size_t __cdecl wcstombs(char *, const wchar_t *, size_t);#ifndef _MAC#ifndef _WSTDLIB_DEFINED/* wide function prototypes, also declared in wchar.h */_CRTIMP wchar_t * __cdecl _itow (int, wchar_t *, int);_CRTIMP wchar_t * __cdecl _ltow (long, wchar_t *, int);_CRTIMP wchar_t * __cdecl _ultow (unsigned long, wchar_t *, int);_CRTIMP double __cdecl wcstod(const wchar_t *, wchar_t **);_CRTIMP long __cdecl wcstol(const wchar_t *, wchar_t **, int);_CRTIMP unsigned long __cdecl wcstoul(const wchar_t *, wchar_t **, in t);_CRTIMP wchar_t * __cdecl _wgetenv(const wchar_t *);_CRTIMP int __cdecl _wsystem(const wchar_t *);_CRTIMP int __cdecl _wtoi(const wchar_t *);_CRTIMP long __cdecl _wtol(const wchar_t *);#if _INTEGRAL_MAX_BITS >= 64_CRTIMP wchar_t * __cdecl _i64tow(__int64, wchar_t *, int);_CRTIMP wchar_t * __cdecl _ui64tow(unsigned __int64, wchar_t *, int);_CRTIMP __int64 __cdecl _wtoi64(const wchar_t *);#endif#define _WSTDLIB_DEFINED#endif#endif /* ndef _MAC */#ifndef _POSIX__CRTIMP char * __cdecl _ecvt(double, int, int *, int *);#if _MSC_VER >= 1200_CRTIMP __declspec(noreturn) void __cdecl _exit(int);#else_CRTIMP void __cdecl _exit(int);#endif_CRTIMP char * __cdecl _fcvt(double, int, int *, int *);_CRTIMP char * __cdecl _fullpath(char *, const char *, size_t);_CRTIMP char * __cdecl _gcvt(double, int, char *);unsigned long __cdecl _lrotl(unsigned long, int);unsigned long __cdecl _lrotr(unsigned long, int);#ifndef _MAC_CRTIMP void __cdecl _makepath(char *, const char *, const char *, co nst char *,const char *);#endif_onexit_t __cdecl _onexit(_onexit_t);_CRTIMP void __cdecl perror(const char *);_CRTIMP int __cdecl _putenv(const char *);unsigned int __cdecl _rotl(unsigned int, int);unsigned int __cdecl _rotr(unsigned int, int);_CRTIMP void __cdecl _searchenv(const char *, const char *, char *);#ifndef _MAC_CRTIMP void __cdecl _splitpath(const char *, char *, char *, char *, ch ar *);#endif_CRTIMP void __cdecl _swab(char *, char *, int);#ifndef _MAC#ifndef _WSTDLIBP_DEFINED/* wide function prototypes, also declared in wchar.h */_CRTIMP wchar_t * __cdecl _wfullpath(wchar_t *, const wchar_t *, size_ t);_CRTIMP void __cdecl _wmakepath(wchar_t *, const wchar_t *, const w char_t *, const wchar_t *,const wchar_t *);_CRTIMP void __cdecl _wperror(const wchar_t *);_CRTIMP int __cdecl _wputenv(const wchar_t *);_CRTIMP void __cdecl _wsearchenv(const wchar_t *, const wchar_t *, w char_t *);_CRTIMP void __cdecl _wsplitpath(const wchar_t *, wchar_t *, wchar_t *, wchar_t *, wchar_t *);#define _WSTDLIBP_DEFINED#endif#endif /* ndef _MAC *//* --------- The following functions are OBSOLETE --------- *//* The Win32 API SetErrorMode, Beep and Sleep should be used instea d. */#ifndef _MAC_CRTIMP void __cdecl _seterrormode(int);_CRTIMP void __cdecl _beep(unsigned, unsigned);_CRTIMP void __cdecl _sleep(unsigned long);#endif /* ndef _MAC *//* --------- The preceding functions are OBSOLETE --------- */#endif /* _POSIX_ */#if !__STDC__/* --------- The declarations below should not be in stdlib.h --------- */ /* --------- and will be removed in a future release. Include --------- */ /* --------- ctype.h to obtain these declarations. --------- */#ifndef tolower /* tolower has been undefined - use function */_CRTIMP int __cdecl tolower(int);#endif /* tolower */#ifndef toupper /* toupper has been undefined - use function */_CRTIMP int __cdecl toupper(int);#endif /* toupper *//* --------- The declarations above will be removed. --------- */#endif#if !__STDC__#ifndef _POSIX_/* Non-ANSI names for compatibility */#ifndef __cplusplus#define max(a,b) (((a) > (b)) ? (a) : (b))#define min(a,b) (((a) < (b)) ? (a) : (b))#endif#define sys_errlist _sys_errlist#define sys_nerr _sys_nerr#define environ _environ_CRTIMP char * __cdecl ecvt(double, int, int *, int *);_CRTIMP char * __cdecl fcvt(double, int, int *, int *);_CRTIMP char * __cdecl gcvt(double, int, char *);_CRTIMP char * __cdecl itoa(int, char *, int);_CRTIMP char * __cdecl ltoa(long, char *, int);onexit_t __cdecl onexit(onexit_t);_CRTIMP int __cdecl putenv(const char *);_CRTIMP void __cdecl swab(char *, char *, int);_CRTIMP char * __cdecl ultoa(unsigned long, char *, int);#endif /* _POSIX_ */#endif /* __STDC__ */#ifdef __cplusplus}#endif#ifdef _MSC_VER#pragma pack(pop)#endif /* _MSC_VER */ #endif /* _INC_STDLIB */。
c++预编译命令
在所有的预处理指令中，#Pragma 指令可能是最复杂的了，它的作用是设定编译器的状态或者是指示编译器完成一些特定的动作。
#pragma指令对每个编译器给出了一个方法,在保持与C和C++语言完全兼容的情况下,给出主机或操作系统专有的特征。
依据定义,编译指示是机器或操作系统专有的,且对于每个编译器都是不同的。
其格式一般为: #Pragma Para其中Para 为参数，下面来看一些常用的参数。
(1)message 参数。
Message 参数是我最喜欢的一个参数，它能够在编译信息输出窗口中输出相应的信息，这对于源代码信息的控制是非常重要的。
其使用方法为：#Pragma message(“消息文本”)当编译器遇到这条指令时就在编译输出窗口中将消息文本打印出来。
当我们在程序中定义了许多宏来控制源代码版本的时候，我们自己有可能都会忘记有没有正确的设置这些宏，此时我们可以用这条指令在编译的时候就进行检查。
假设我们希望判断自己有没有在源代码的什么地方定义了_X86这个宏可以用下面的方法#ifdef _X86#Pragma message(“_X86 macro activated!”)#endif当我们定义了_X86这个宏以后，应用程序在编译时就会在编译输出窗口里显示“_ X86 macro activated!”。
我们就不会因为不记得自己定义的一些特定的宏而抓耳挠腮了。
(2)另一个使用得比较多的pragma参数是code_seg。
格式如：#pragma code_seg( ["section-name"[,"section-class"] ] )它能够设置程序中函数代码存放的代码段，当我们开发驱动程序的时候就会使用到它。
(3)#pragma once (比较常用）只要在头文件的最开始加入这条指令就能够保证头文件被编译一次，这条指令实际上在VC6中就已经有了，但是考虑到兼容性并没有太多的使用它。
C语言stdlib.h函数库
stdlib.h用法1函数名称:callo c函数原型:void* cal loc(u nsign ed n,unsig n siz e);函数功能: 分配n个数据项的内存连续空间,每个数据项的大小为size 函数返回: 分配内存单元的起始地址,如果不成功,返回02函数名称:free函数原型: vo id fr ee(vo id* p);函数功能:释放p所指的内存区函数返回:参数说明: p-被释放的指针3函数名称:mallo c函数原型:void* mal loc(u nsign ed si ze);函数功能: 分配size字节的存储区函数返回: 所分配的内存区地址,如果内存不够,返回04函数名称: r eallo c函数原型:void* rea lloc(void* p,u nsign ed si ze);函数功能: 将p所指出的已分配内存区的大小改为size,size可以比原来分配的空间大或小函数返回:返回指向该内存区的指针.NU LL-分配失败5函数名称: ran d函数原型:int r and(v oid);函数功能: 产生0到32767间的随机整数(0到0x7fff之间)函数返回:随机整数6函数名称: a bort函数原型: vo id ab ort(v oid)函数功能: 异常终止一个进程.7函数名称: exi t函数原型:voidexit(int s tate)函数功能: 程序中止执行，返回调用过程函数返回:参数说明: s tate:0-正常中止，非0-非正常中止8函数名称:geten v函数原型:char* gete nv(co nst c har *name)函数功能: 返回一个指向环境变量的指针函数返回:环境变量的定义参数说明: nam e-环境字符串9函数名称: put env函数原型: int pute nv(co nst c har *name)函数功能: 将字符串na me增加到DOS环境变量中函数返回: 0:操作成功，-1:操作失败参数说明:name-环境字符串10函数名称: labs函数原型: l ong l abs(l ong n um)函数功能: 求长整型参数的绝对值函数返回:绝对值11函数名称:atof函数原型: do ubleatof(char*str)函数功能: 将字符串转换成一个双精度数值函数返回: 转换后的数值参数说明: str-待转换浮点型数的字符串12函数名称: at oi函数原型: intatoi(char*str)函数功能: 将字符串转换成一个整数值函数返回:转换后的数值参数说明:str-待转换为整型数的字符串13函数名称: atol函数原型: l ong a tol(c har *str)函数功能: 将字符串转换成一个长整数函数返回: 转换后的数值参数说明: s tr-待转换为长整型的字符串14函数名称:ecvt函数原型: ch ar *e cvt(d ouble valu e,int ndig it,in t *de c,int *sig n) 函数功能:将浮点数转换为字符串函数返回:转换后的字符串指针参数说明: va lue-待转换底浮点数，ndi git-转换后的字符串长度15函数名称: f cvt函数原型: cha r *fc vt(do ublevalue,intndigi t,int *dec,int*sign) 函数功能:将浮点数变成一个字符串函数返回:转换后字符串指针参数说明: val ue-待转换底浮点数，ndig it-转换后底字符串长度。
c语言中数学函数
C语言中之数学函数C语言提供了以下的数学函数，要使用这些函数时，在程序文件头必须加入：#include <math.h>编译时，必须加上参数「-lm」（表示连结至数学函式库），例如「gcc -lm test.c」。
函数之自变量与传回之值型别见自变量或函数前之型别宣告。
函数已经在「math.h」或其它标头档宣告过了，因此在使用时不必再加型别宣告，例如「y=sin(x);」，不用写成「y=double sin(double x);」。
函数说明double sin(double x)x 的正弦函数值double cos(double x)x 的余弦函数值double tan(double x)x 的正切函数值double asin(double x)x 的反正弦函数值sin-1x，x的值在[-1,1] 之间，传回的值在[-p/2,p/2] 之间double acos(double x)x 的反余弦函数值cos-1x，x的值在[-1,1] 之间，传回的值在[-p/2,p/2] 之间double atan(double x)x 的反正切函数值tan-1x，传回的值在[-p/2,p/2] 之间double atan2(double y, double x)y/x 的反正切函数值tan-1(y/x)，传回的值在[-p, p] 之间double sinh(double x)x 的双曲正弦函数值double cosh(double x)x 的双曲余弦函数值double tanh(double x)x 的双曲正切函数值double exp(double x)x 的指数函数exdouble log(double x)x 的自然对数ln(x)，x > 0double log10(double x)x 底数为10 的对数，log10x，x > 0double pow(double x, double y)x 的y 次方xydouble sqrt(double x)x 的根号值√xdouble ceil(double x)不小于x 的最小整数（但其型别为double）double floor(double x)不大于x 的最大整数（但其型别为double）int abs(int x)整数x 的绝对值|x|long labs(long x)长整数x 的绝对值|x|double fabs(double x)实数x 的绝对值|x|double ldexp(double x, int n)x?2ndouble fmod(double x, double y)x/y 的浮点数余数，符号与x 相同范例：各个数学函式的使用方法#include <stdio.h>#include <math.h>#define PI 3.14159int main(void){double x,y,z;int n;x=4.0;y=sqrt(x);printf("x=%fty=%fn",x,y);x=PI/4;y=sin(x);printf("x=%fty=%fn",x,y);x=2.0;y=3.0;z=pow(x,y);printf("x=%fty=%ftz=%fn",x,y,z);x=1.5;n=4;y=ldexp(x,n);printf("x=%ftn=%dty=%fn",x,n,y);return 0;}c++中string与string.h 的作用和区别#include <string.h>void main(){string aaa= "abcsd d";printf("looking for abc from abcdecd %s\n", (strcmp(aaa,"abc")) ? "Found" : "Not Found"); }不能正确执行，提示说是string类型没有定义而下面：#include <string>using namespace std;void main(){string aaa= "abcsd d";printf("looking for abc from abcdecd %s\n", (strcmp(aaa,"abc")) ? "Found" : "Not Found");}这里的string编译器就认识了，但是strcmp就不认识了呢？一般一个C++的老的带“.h”扩展名的库文件，比如iostream.h，在新标准后的标准库中都有一个不带“.h”扩展名的相对应，区别除了后者的好多改进之外，还有一点就是后者的东东都塞进了“std”名字空间中。
常用的c++头文件大全
#include <iomanip.h> //参数化输入／输出#include <iostream.h> //数据流输入／输出#include <stdio.h> //标准输入／输出函数在使用标准函数库中的输入输出函数时，编译系统要求程序提供有关的信息（例如对这些输入输出函数的声明），#include<stdio.h>的作用就是用来提供这些信息的，stdio.h是C编译系统提供的一个文件名，stdio是“standard input & output”的缩写，即有关标准输入输出的信息。
在程序中用到系统提供的标准函数库中的输入输出函数时，应在程序的开头写上一行：#include"stdio.h"或者是#include<stdio.h>,这样才能调用库函数#include <iomanip.h> //参数化输入／输出#include <string.h> //字符串处理#include <iomanip>在c++程序里面经常见到下面的头文件#include <iomanip>这里面iomanip的作用比较多:主要是对cin,cout之类的一些操纵运算子，比如setfill,setw,setbase,setprecision等等。
它是I/O流控制头文件,就像C里面的格式化输出一样.以下是一些常见的控制函数的: dec 置基数为10 相当于"%d"hex 置基数为16 相当于"%X"oct 置基数为8 相当于"%o"setfill(c) 设填充字符为csetprecision(n) 设显示小数精度为n位setw(n) 设域宽为n个字符这个控制符的意思是保证输出宽度为n。
如：cout<<setw(3)<<1<<setw(3)<<10<<setw(3)<<100; 输出结果为 1 10100 （默认是右对齐）当输出长度大于3时(<<1000)，setw(3)不起作用。
createprocess异步读取管道数据的代码实现-概述说明以及解释
createprocess异步读取管道数据的代码实现-概述说明以及解释1.引言1.1 概述在现代软件开发中，经常会遇到需要创建子进程并与之交互的场景。
而在子进程的执行过程中，我们往往需要从子进程的输出中获取数据，以便进行后续的处理和分析。
而CreateProcess函数是Windows系统中用于创建新进程的API函数，它可以实现创建子进程并与之进行通信的功能。
然而，在使用CreateProcess函数创建子进程时，我们常常需要读取子进程的输出信息，以便及时处理。
但是由于子进程的输出是通过管道进行传输的，而管道的读取操作是阻塞式的，即当没有数据可读时，读取操作会一直阻塞，直到有数据可读为止。
这就给我们的程序带来了一定的困扰，因为当程序阻塞在读取管道的地方时，无法进行其他重要的操作。
为了解决这个问题，我们可以利用异步读取管道数据的方法。
异步读取管道数据的主要思想是通过创建一个子线程，在该线程中进行管道的读取操作，并将读取到的数据暂存起来，供主线程使用。
这样，主线程可以继续进行其他操作，而不会因为阻塞在读取管道的地方而无法前进。
本文将主要介绍如何利用CreateProcess函数创建子进程，并通过异步读取管道数据的方式，实现与子进程的交互。
首先，我们将介绍如何创建进程并建立管道；接着，我们将详细讲解如何实现异步读取管道数据的方法。
最后，我们将进行本文的总结和结论。
接下来，让我们开始了解如何创建进程并建立管道的具体步骤。
1.2文章结构文章结构：本文共分为以下几个部分：1. 引言：在这一部分，将对文章的主题进行概述，介绍本文的结构和目的。
2. 正文：本文正文分为两个主要部分：2.1 创建进程并建立管道：在这一部分，将详细介绍如何使用CreateProcess函数创建进程，并建立起进程间通信的管道。
2.2 实现异步读取管道数据：这是本文的重点部分，将介绍如何通过异步方式读取管道中的数据，以提高程序的效率和性能。
C（C++）输入输出格式
C（C++）输⼊输出格式c&c++输⼊输出控制格式许多情况下，都需要控制输出结果的表现形式。
如输出宽度、输出精度、输出格式等。
C++的iomanip.h中定义了许多控制符，这些控制符可以直接插⼊到流中，控制数据的输出格式。
控制符有两种：控制常量和控制函数，控制常量定义在iostream.h中，控制函数定义在iomanip.h 中。
常⽤控制符在iostream.h中，函数控制符在iomainip.h中。
控制符描述dec 10进制hex 16进制oct 8进制setfill（c）设填充字符为csetprecision（n）设置显⽰⼩数精度为n位setw（n）设域宽为n个⼦符setiosflags（ios::fixed）⼩数⽅式表⽰setiosflags（ios::scientific）指数表⽰setiosflags（ios::left）左对齐setiosflags（ios::right）右对齐setiosflags（ios::skipws）忽略前导空⽩（⽤于输⼊）setiosflags（ios::uppercase） 16进制数⼤写输出setiosflags（ios::lowercase） 16进制数⼩写输出注意：除了setw（n）控制符之外，其他控制符对后⾯的所有输出起控制作⽤，直到改变输出格式为⽌。
例1、输出8进制和16进制数常量dec、hex和oct⽤来控制必须按10进制、16进制或8进制形式输出。
1 #include<iostream>2using namespace std;3int main()4 {5int number=15;6 cout<<dec<<number<<"\n"<<hex<< number<<"\n"<<oct<<number<<"\n";7return0;8 }结果为：15f17注意：由于这三个标识符已经被定义为系统常量，注意不能在定义为其他变量使⽤。
vscode .h 头文件的规则 -回复
vscode .h 头文件的规则-回复标题：[VSCode .h 头文件的规则]：一份全面的指南在编程中，头文件（.h）是一个重要的组成部分，它包含了程序中的函数声明、宏定义以及类型定义等信息。
对于C++开发者来说，了解并正确使用头文件是至关重要的。
本文将详细介绍如何在Visual Studio Code（简称VSCode）中正确使用.h头文件。
一、什么是头文件？头文件是一种包含程序声明和定义的文件，通常以".h"作为扩展名。
这些文件被包含在源代码文件中，使得源代码能够访问到头文件中声明的变量、函数或类等元素。
例如，C++标准库中的iostream库就是一个头文件，我们通过#include <iostream>来引入这个头文件，从而可以使用其中的cout、cin等函数。
二、为什么要使用头文件？1. 提高代码复用性：头文件可以被多个源文件引用，使得我们可以轻松地在不同的地方使用相同的函数或者数据结构。
2. 降低编译时间：头文件只包含声明，不包含实现。
这样，当一个函数的实现发生变化时，只需要重新编译该函数所在的源文件，而不需要重新编译所有引用了该函数的源文件。
三、如何在VSCode中使用头文件？1. 创建头文件：首先，在你的项目目录下创建一个新的头文件。
例如，如果你要创建一个名为"myMath"的头文件，你可以右键点击项目目录，选择"新建文件"，然后输入文件名"myMath.h"。
2. 编写头文件内容：打开你刚刚创建的头文件，开始编写你的函数声明或者宏定义。
例如：cppmyMath.h#ifndef MY_MATH_H#define MY_MATH_Hint add(int a, int b);int subtract(int a, int b);#endif这里，我们定义了一个名为MY_MATH_H的宏，用来防止头文件被重复包含。
C++程序设计教学大纲(初级中级)
第一部分：c++的入门，基本数据类型和输入输出，表达式和语句，以及过程化语句1. 写出c＋＋最简单的程序的模板答：#include<iostream>using namespace std;int main(void)错误！未找到索引项。
{cout<<"hello world"<<endl;return 0;}2. c++的注释方式答：(1) //(2)/* something */3. c++中不同的教材中#include<iostream.h>和#include<iostream>的区别答：(1)#include<iostream.h>是标准化以前的头文件，现在的保留是为了以前程序代码的使用，但不在官方的标准中，同时<iostream.h>中的声明是全局的。
（2）＃include<iostream>是ＡＮＳＩ标准委员会提供的头文件，同时包含在STD的名字空间中，因此使用的时候要加上using namespace std;（3）为了程序对C的兼容，#include<stdio.h>类似的头文件仍然可以使用，但不包含在std名字空间之中。
（4）标准对c的<stdio.h>类似的头文件做了改进，同时包含在std的名字空间之中，为了和旧的c头文件的区别，使用#include<cstdio>;4. c++的常用保留字有哪些？答：(1) Ansi C规定32个保留字，ansi c++新增加29个保留字。
主要有：bool,catch,calss,delete,friend,inline,new,operator,private,protected,public,template,this,thow,true,v irtual.5. c++中的基本数据类型有哪些？答：(1)基本数据类型：int,char,wchar_t,float,double,bool,type[],type*,void,struct,union,enum,class,string,vector,list,set, multiset,multimap,map,pair,stack,deque,引用数据类型。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
strcpy(p, p1) 复制字符串strncpy(p, p1, n) 复制指定长度字符串strcat(p, p1) 附加字符串strncat(p, p1, n) 附加指定长度字符串strlen(p) 取字符串长度strcmp(p, p1) 比较字符串strcasecmp忽略大小写比较字符串strncmp(p, p1, n) 比较指定长度字符串strchr(p, c) 在字符串中查找指定字符strrchr(p, c) 在字符串中反向查找strstr(p, p1) 查找字符串strpbrk(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找该集合的任一元素strspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找不属于该集合的任一元素的偏移strcspn(p, p1) 以目标字符串的所有字符作为集合，在当前字符串查找属于该集合的任一元素的偏移* 具有指定长度的字符串处理函数在已处理的字符串之后填补零结尾符2）字符串到数值类型的转换strtod(p, ppend) 从字符串p 中转换double 类型数值，并将后续的字符串指针存储到ppend 指向的char* 类型存储。
strtol(p, ppend, base) 从字符串p 中转换long 类型整型数值，base 显式设置转换的整型进制，设置为0 以根据特定格式判断所用进制，0x, 0X 前缀以解释为十六进制格式整型，0 前缀以解释为八进制格式整型atoi(p) 字符串转换到int 整型atof(p) 字符串转换到double 符点数atol(p) 字符串转换到long 整型isalpha() 检查是否为字母字符isupper() 检查是否为大写字母字符islower() 检查是否为小写字母字符isdigit() 检查是否为数字isxdigit() 检查是否为十六进制数字表示的有效字符isspace() 检查是否为空格类型字符iscntrl() 检查是否为控制字符ispunct() 检查是否为标点符号isalnum() 检查是否为字母和数字isprint() 检查是否是可打印字符isgraph() 检查是否是图形字符，等效于isalnum() | ispunct() 4）函数原型原型：strcpy(char destination[], const char source[]);功能：将字符串source拷贝到字符串destination中例程：#include <iostream.h>#include <string.h>void main(void){char str1[10] = { "TsinghuaOK"};char str2[10] = { "Computer"};cout <<strcpy(str1,str2)<<endl;}运行结果是:Computer第二个字符串将覆盖掉第一个字符串的所有内容！注意：在定义数组时，字符数组1的字符串长度必须大于或等于字符串2的字符串长度。
不能用赋值语句将一个字符串常量或字符数组直接赋给一个字符数组。
所有字符串处理函数都包含在头文件string.h中。
strncpy(char destination[], const char source[], int numchars);strncpy：将字符串source中前numchars个字符拷贝到字符串destination中。
strncpy函数应用举例原型：strncpy(char destination[], const char source[], int numchars);功能：将字符串source中前numchars个字符拷贝到字符串destination中例程：#include <iostream.h>#include <string.h>void main(void){char str1[10] = { "Tsinghua "};char str2[10] = { "Computer"};cout <<strncpy(str1,str2,3)<<endl;}运行结果：Comnghua注意：字符串source中前numchars个字符将覆盖掉字符串destination中前numchars个字符！原型：strcat(char target[], const char source[]);功能：将字符串source接到字符串target的后面例程：#include <iostream.h>#include <string.h>void main(void){char str1[] = { "Tsinghua "};char str2[] = { "Computer"};cout <<strcpy(str1,str2)<<endl;}运行结果：Tsinghua Computer注意：在定义字符数组1的长度时应该考虑字符数组2的长度，因为连接后新字符串的长度为两个字符串长度之和。
进行字符串连接后，字符串1的结尾符将自动被去掉，在结尾串末尾保留新字符串后面一个结尾符。
原型：strncat(char target[], const char source[], int numchars);功能：将字符串source的前numchars个字符接到字符串target的后面例程：#include <iostream.h>#include <string.h>void main(void){char str1[] = { "Tsinghua "};char str2[] = { "Computer"};cout <<strncat(str1,str2,3)<<endl;}运行结果：Tsinghua Com原型：int strcmp(const char firststring[], const char secondstring);功能：比较两个字符串firststring和secondstring例程：#include <iostream.h>#include <string.h>void main(void){char buf1[] = "aaa";char buf2[] = "bbb";char buf3[] = "ccc";int ptr;ptr = strcmp(buf2,buf1);if(ptr > 0)cout <<"Buffer 2 is greater than buffer 1"<<endl;elsecout <<"Buffer 2 is less than buffer 1"<<endl;ptr = strcmp(buf2,buf3);if(ptr > 0)cout <<"Buffer 2 is greater than buffer 3"<<endl;elsecout <<"Buffer 2 is less than buffer 3"<<endl;}运行结果是:Buffer 2 is less than buffer 1Buffer 2 is greater than buffer 3原型：strlen( const char string[] );功能：统计字符串string中字符的个数例程：#include <iostream.h>#include <string.h>void main(void){char str[100];cout <<"请输入一个字符串:";cin >>str;cout <<"The length of the string is :"<<strlen(str)<<"个"<<endl;}运行结果The length of the string is x (x为你输入的字符总数字)注意：strlen函数的功能是计算字符串的实际长度，不包括'\0'在内。
另外，strlen函数也可以直接测试字符串常量的长度，如：strlen("Welcome")。
void *memset(void *dest, int c, size_t count);将dest前面count个字符置为字符c. 返回dest的值.void *memmove(void *dest, const void *src, size_t count);从src复制count字节的字符到dest. 如果src和dest出现重叠, 函数会自动处理. 返回dest的值.void *memcpy(void *dest, const void *src, size_t count);从src复制count字节的字符到dest. 与memmove功能一样, 只是不能处理src和dest出现重叠. 返回dest的值. void *memchr(const void *buf, int c, size_t count);在buf前面count字节中查找首次出现字符c的位置. 找到了字符c或者已经搜寻了count个字节, 查找即停止. 操作成功则返回buf中首次出现c的位置指针, 否则返回NULL.void *_memccpy(void *dest, const void *src, int c, size_t count);从src复制0个或多个字节的字符到dest. 当字符c被复制或者count个字符被复制时, 复制停止.如果字符c被复制, 函数返回这个字符后面紧挨一个字符位置的指针. 否则返回NULL.int memcmp(const void *buf1, const void *buf2, size_t count);比较buf1和buf2前面count个字节大小.返回值< 0, 表示buf1小于buf2;返回值为0, 表示buf1等于buf2;返回值> 0, 表示buf1大于buf2.int memicmp(const void *buf1, const void *buf2, size_t count);比较buf1和buf2前面count个字节. 与memcmp不同的是, 它不区分大小写.返回值同上.char *strrev(char *string);将字符串string中的字符顺序颠倒过来. NULL结束符位置不变. 返回调整后的字符串的指针.char *_strupr(char *string);将string中所有小写字母替换成相应的大写字母, 其它字符保持不变. 返回调整后的字符串的指针.char *_strlwr(char *string);将string中所有大写字母替换成相应的小写字母, 其它字符保持不变. 返回调整后的字符串的指针.char *strchr(const char *string, int c);查找字串string中首次出现的位置, NULL结束符也包含在查找中. 返回一个指针, 指向字符c在字符串string中首次出现的位置, 如果没有找到, 则返回NULL.char *strrchr(const char *string, int c);查找字符c在字符串string中最后一次出现的位置, 也就是对string进行反序搜索, 包含NULL结束符.返回一个指针, 指向字符c在字符串string中最后一次出现的位置, 如果没有找到, 则返回NULL.char *strstr(const char *string, const char *strSearch);在字符串string中查找strSearch子串. 返回子串strSearch在string中首次出现位置的指针. 如果没有找到子串strSe arch, 则返回NULL. 如果子串strSearch为空串, 函数返回string值.char *strdup(const char *strSource);函数运行中会自己调用malloc函数为复制strSource字符串分配存储空间, 然后再将strSource复制到分配到的空间中.注意要及时释放这个分配的空间.返回一个指针, 指向为复制字符串分配的空间; 如果分配空间失败, 则返回NULL值.char *strcat(char *strDestination, const char *strSource);将源串strSource添加到目标串strDestination后面, 并在得到的新串后面加上NULL结束符. 源串strSource的字符会覆盖目标串strDestination后面的结束符NULL. 在字符串的复制或添加过程中没有溢出检查, 所以要保证目标串空间足够大. 不能处理源串与目标串重叠的情况. 函数返回strDestination值.char *strncat(char *strDestination, const char *strSource, size_t count);将源串strSource开始的count个字符添加到目标串strDest后. 源串strSource的字符会覆盖目标串strDestination后面的结束符NULL. 如果count大于源串长度, 则会用源串的长度值替换count值. 得到的新串后面会自动加上NULL结束符. 与strcat函数一样, 本函数不能处理源串与目标串重叠的情况. 函数返回strDestination值.char *strcpy(char *strDestination, const char *strSource);复制源串strSource到目标串strDestination所指定的位置, 包含NULL结束符. 不能处理源串与目标串重叠的情况.函数返回strDestination值.char *strncpy(char *strDestination, const char *strSource, size_t count);将源串strSource开始的count个字符复制到目标串strDestination所指定的位置. 如果count值小于或等于strSource 串的长度, 不会自动添加NULL结束符目标串中, 而count大于strSource串的长度时, 则将strSource用NULL结束符填充补齐count个字符, 复制到目标串中. 不能处理源串与目标串重叠的情况.函数返回strDestination值.char *strset(char *string, int c);将string串的所有字符设置为字符c, 遇到NULL结束符停止. 函数返回内容调整后的string指针.char *strnset(char *string, int c, size_t count);将string串开始count个字符设置为字符c, 如果count值大于string串的长度, 将用string的长度替换count值. 函数返回内容调整后的string指针.size_t strspn(const char *string, const char *strCharSet);查找任何一个不包含在strCharSet串中的字符(字符串结束符NULL除外) 在string串中首次出现的位置序号. 返回一个整数值, 指定在string中全部由characters中的字符组成的子串的长度. 如果string以一个不包含在strCharSet中的字符开头, 函数将返回0值.size_t strcspn(const char *string, const char *strCharSet);查找strCharSet串中任何一个字符在string串中首次出现的位置序号, 包含字符串结束符NULL.返回一个整数值, 指定在string中全部由非characters中的字符组成的子串的长度. 如果string以一个包含在strCharS et中的字符开头, 函数将返回0值.char *strspnp(const char *string, const char *strCharSet);查找任何一个不包含在strCharSet串中的字符(字符串结束符NULL除外) 在string串中首次出现的位置指针. 返回一个指针, 指向非strCharSet中的字符在string中首次出现的位置.char *strpbrk(const char *string, const char *strCharSet);查找strCharSet串中任何一个字符在string串中首次出现的位置, 不包含字符串结束符NULL.返回一个指针, 指向strCharSet中任一字符在string中首次出现的位置. 如果两个字符串参数不含相同字符, 则返回NU LL值.int strcmp(const char *string1, const char *string2);比较字符串string1和string2大小.返回值< 0, 表示string1小于string2;返回值为0, 表示string1等于string2;返回值> 0, 表示string1大于string2.int stricmp(const char *string1, const char *string2);比较字符串string1和string2大小，和strcmp不同, 比较的是它们的小写字母版本.返回值与strcmp相同.int strcmpi(const char *string1, const char *string2);等价于stricmp函数, 只是提供一个向后兼容的版本.int strncmp(const char *string1, const char *string2, size_t count);比较字符串string1和string2大小，只比较前面count个字符. 比较过程中, 任何一个字符串的长度小于count, 则cou nt将被较短的字符串的长度取代. 此时如果两串前面的字符都相等, 则较短的串要小.返回值< 0, 表示string1的子串小于string2的子串;返回值为0, 表示string1的子串等于string2的子串;返回值> 0, 表示string1的子串大于string2的子串.int strnicmp(const char *string1, const char *string2, size_t count);比较字符串string1和string2大小，只比较前面count个字符. 与strncmp不同的是, 比较的是它们的小写字母版本. 返回值与strncmp相同.char *strtok(char *strToken, const char *strDelimit);在strToken 串中查找下一个标记, strDelimit字符集则指定了在当前查找调用中可能遇到的分界符. 返回一个指针, 指向在strToken中找到的下一个标记. 如果找不到标记, 就返回NULL值. 每次调用都会修改strToken内容, 用NULL字符替换遇到的每个分界符.c++概念字符串操作一、char_traits 字符特征类1）意义：包装特定串元素的通用行为界面，以便容器实现时依据特征信息而执行特定行为2）定义了通用类型名typedef _Elem char_type;typedef int int_type;typedef streampos pos_type;typedef streamoff off_type;typedef mbstate_t state_type;其中int_type 表示字符元素转换到特定编码时的整型表示，pos_type, off_type 分别作为字符串索引和字符串元素偏移的类型，类似容器迭中的指针，迭代类型和指针，迭代器的偏移类型。