人类工程师的博客

C++ 11 不定参数模板

成员函数,友元函数,友元类

C++ 链表操作

字符串和字符数组的区别

C++ tie() 用法

自动刷新缓冲区

让一个类的成员函数作为另一个类的友元函数

位操作

关于数组输出

C++耻辱柱

C++ 耻辱

简介C++0x中引入了static_assert这个关键字，用来做编译期间的断言，因此叫做静态断言。其语法很简单：static_assert(常量表达式，提示字符串)。如果第一个参数常量表达式的值为真(true或者非零值)，那么static_assert不做任何事情，就像它不存在一样，否则会产生一条编译错误，错误位置就是该static_assert语句所在行，错误提示就是第二个参数提示字符串。说明使用static_assert，我们可以在编译期间发现更多的错误，用编译器来强制保证一些

C++是兼容C的，因此C语言中的强制类型转换在C++中同样适用，具体使用方法可以参照下面的代码示例：float valueA = 3.0f;int valueB = (int) valueA;可以看到，C语言中强制类型转换的一般格式为：（类型说明符）表达式实现的功能就是把表达式的值强制转换为类型说明符表示的类型。除了这种强制类型转换方法外，C++还提供了四种类型转换方法，分别为static_cast<类型说明符>(表达式） C++强制类型转换操作符 static_

lambda表达式就是无名函数（没有函数名子的函数）#include <iostream>using namespace std;int Sum(int a,int b){ return a+b;}int main(){ //lambda表达式就是无名函数（没有函数名子的函数） //下面是一个完整的lambda表达式模型，实现功能和Sum一样 //[]捕获列表 ()参数列表 ->返回类型 /* [](int a,i

轮询查看#include<iostream>#include"osapi/osapi.h"using namespace std;OS_Mutex g_mutex;int g_Buffer[100];int g_Count = 0;class Producer : public OS_Thread{public: bool quitFlag; Producer() :quitFlag(true) {} void start() { quitFlag = fa

可重入（reentrant）得函数，又称线程安全(thread safe)的函数是指一个函数，在多个线程里同时调用（并发调用）的时候，其功能任然正常原则：（1）没有外部依赖，不操作函数范围外的变量，例如全局变量尽量用本函数内定义的局部变量来实现，或者在本函数内动态创建对象，并在退出时销毁对象（2）如果不行的话，加上互斥锁控制，保证一个程序正常运行完毕#include<iostream>#include"osapi/osapi.h"using namespace std;

#include<iostream>#include"osapi/osapi.h"using namespace std;int g_number = 10086;class TaskA : public OS_Thread{public: bool quitflag; void start() { quitflag = false; Run(); } void stop() { quitflag = true; Join(this); }priv.

结束主线程之前，让子线程正常退出并做好善后工作#include<iostream>#include"osapi/osapi.h"using namespace std;class Buddhist : public OS_Thread{public: bool quitflag;private: virtual int Routine() { for (int i = 0; !quitflag && i < 100; i++) { c

1.认识到函数调用无法实现并行任务2.初步理解线程的概念，创建第一个线程3.学会用Sleep来让出CPU#include<iostream>#include"osapi/osapi.h"using namespace std;class Buddhist: public OS_Thread{public:private: virtual int Routine() { for (int i = 0; i < 100; i++) { cout&

#include <iostream>using namespace std;template <typename Type>class PushOnStackFull//异常类的定义{private: Type value; string str; public: PushOnStackFull(const char* s,int val):str(s),value(val){} ~PushOnStackFull(){}public.

#include <iostream>using namespace std; float Div(int a,int b)//throw(int,float)//表示只允许返回这两种类型异常{ if(b == 0) { short x; throw x; } return a*1.0/b;} int main(){ int a; int b; cin>>a>>b;.

在系统加载的时候，从构造函数中读入数据在系统结束的时候，在析构函数中存储数据#include <iostream>#include<fstream>using namespace std;class Complex{private: int real; int img;public: Complex(); Complex(int r,int i):real(r),img(i){}; void SetComplex(int.

提取运算符用于从输入流对象中提取数据，提取运算符">>",适用于任何输入流对象，如输入文件流ifstrea等，右侧可以是使用提取任意标准数据类型的变量，也可以是字符串变量（字符数组或者字符指针），使用运算符提取数据时，以空白符(空格、enter、tab)作为数据的分隔符，因此提取字符串数据时不能提取空白字符#include <iostream>#include <iomanip>using namespace std;int main(){ int

1.cout的put和write方法#include<iostream>#include<cstring>using namespace std;int main(){ cout.put('A').put('B').put('\n');//输出单个字符 const char* str = "hello world\n"; cout.write(str,strlen(str)+1); //输出一串字符，第一个参数字符串地址，第二参数要输出

windows:EOF首先在最后一行结束后（此时未换行）输入ENTER键，新起一行，再输入ctrl+z，再输入时ENTER键即可。Linux:EOF直接按CTRL+D快捷键写文件#include<iostream>#include<fstream>//引入文件流库using namespace std;int main(){ int a[3] = {1,2,3}; ofstream OutputFile ;//1.创建输出流的文件流.

#include<iostream>using namespace std; class Animal//纯虚类，无法定义对象，但是可以定义指针{private://纯虚类，不需要具体的实现public://为所有子对象提供一个公共的接口 virtual void eat(void)=0;//纯虚函数无需实现，需要在子类中重写 virtual void sleep(void)=0;//=0的本质是指向函数的指针赋值为NULL}; class Mankind:p.

放

#include<iostream>using namespace std;class Animal{private:public: virtual void eat(void){cout<<"eat"<<endl;}};class Mankind:public Animal{private:public: void eat(void){cout<<"eat rice"<<endl;}};class Do.

多态性是面向对象程序设计的关键技术之一。若程序设计语言不支持多态性，不能称为面向对象的语言。利用多态性技术，可以调用同一个函数名的函数，实现完全不同的功能。在C++中有两种多态性1.编译时的多态性通过函数的重载和运算符的重载来实现的。运行时的多态性2.运行时的多态性是指在程序执行前，无法根据函数名和参数来确定该调用哪一个函数，必须在程序执行过程中，根据执行的具体情况来动态地确定。它是通过类继承关系和虚函数来实现的。目的也是建立一种通用的程序。通用性是程序追求的主要目标之一。概念一，虚函..

子类生成四个步骤：1.吸收父类成员不论是数据成员还是函数成员，除了构造函数和析构函数外全盘吸收2.改造子类成员声明一个和某类成员同名的新成员，子类的新成员就屏蔽了父类的同名成员，称为同名覆盖3.发展新成员子类新成员必须与父类成员不同名，他的加入保证子类在功能上有所发展4.重写构造和析构函数...

儿子继承父亲和母亲，父母亲又继承人类，导致人类在儿子中开辟了两份重复的数据#include <iostream>using namespace std;class Man{private: int data;public: Man(int a = 0) : data(a){ cout << "构造Man" << data << endl; } ~Man() { cout << "析构Man" <<

先构造父类，再构造子类，父类构造按照继承先后顺序构造，而后构造子类的属性#include<iostream>using namespace std;class Father{private: int data;public: Father(int a) :data(a) { cout << "构造Father" << a << endl; } ~Father() { cout << "析构Father" &

#include<iostream>using namespace std;class father{private: int a;protected: int b;public: int c;};class son:public father{private: int a;};int main(){ cout<<sizeof(son)<<endl; return 0;}[root@.

#include <iostream>using namespace std;class Int {private: int data;public: Int(int i=0):data(i) { cout << "构造对象"<< data << endl; } ~Int() { cout << "析构对象" << data << endl; .

一般来说，使用new申请空间时，是从系统的“堆”（heap）中分配空间。申请所得的空间的位置时根据当时的内存的实际使用情况决定的。但是，在某些特殊情况下，可能需要在程序员指定的特定内存创建对象，这就是所谓的“定位放置new”（placement new）操作定位放置new操作的语法形式不同于普通的new操作。例如，一般都用如下语句A* p=new A;申请空间，而定位放置new操作则使用如下语句A* p=new (ptr) A;申请空间，其中ptr就是程序员指定的内存首地址。考察如下程序。#in.

String* p = new String("hello world2"); delete p; //上面这两行代码在C++中做了哪些事 //1.申请空间 //2.调用构造函数 //3.调用析构函数 //4.释放p所指向的空间#include <iostream>#include <cstring>using namespace std;class String{ private: cha...

探究动态对象的构造过程#include<iostream>using namespace std;class A{private: int data;public: A(int i):data(i){} //~A(); void InitObject(int i){data=i;} void Destroy(A* p){data =0;}//删除所有数据和动态内存 void FreeObject(A* p){ D.

#include<iostream>using namespace std;template <typename type>class Array {private: int size; type* p;public: Array(int size, type initValue); type& operator[](int index); void show();};template <typename ty.

代码冗余程度高#include<iostream>using namespace std;char MAX(char a,char b){ return a>b?a:b;}int MAX(int a,int b){ return a>b?a:b;}float MAX(float a,float b){ return a>b?a:b;}double MAX(double a,double b){ return a&gt

1.静态变量和静态方法#include<iostream>using namespace std;class Bank{private: const char* name; double money;public: Bank(const char* name, double money = 0.01) :name(name), money(money) { accountSum++; }; ~Bank() { accountSum--; };p