**
关于源文件与头文件：代码：头文件代码
**：#includenamespace pers {
struct person {
std::string fname;
std::string lname;};
void getperson(person&);
void show(const person&);}
namespace debts {
using namespace pers;
struct debt {
person name;
double amount;
};
void getdebt(debt&);
void showdebt(const debt&);
double sum(const debt ar[], int n);}源文件（两个）：第一个：通过包含头文件，导入了原来的名称空间，然后该文件将函数定义添加到两个名称空间中。#include
#include “源.cpp"using namespace debts;
namespace pers {
using std::cout;
using std::cin;
void getperson(person& rp) {
cout << “enter fname”;
cin >> rp.fname;
cin >> rp.lname;
}
void show(const person & rp) {
cout << rp.fname;
cout << rp.lname << “\t”; }
}
namespace debts {void getdebt(debt&rp) {
getperson(rp.name);
cout << “please enter debt”;
cin >> rp.amount;}
void showdebt(const debt&rp)
{
show(rp.name);
cout << rp.amount;
}double sum(const debt ar[], int n) {
double am = 0;
for (int i = 0; i < n; i++)
am += ar[i].amount;
return am;
}}第二个：含有主函数main#include
#include"源.cpp”
void other(void);
void another(void);
using namespace std;
using namespace pers;
using namespace debts;
int main() {
debt golf = { {“ben”,“jieming”},32.1 };
showdebt(golf);
other();}
void other() {
person dg = { “ii”,“derw” };
show(dg);
cout << endl;
debt dogg[3];
int i;
for (i = 0; i < 3; i++)
getdebt(dogg[i]);
for (i = 0; i < 3; i++)
showdebt(dogg[i]);
cout << “tatol debt $” << sum(dogg, 3);}
关于从键盘正确输入一个东西并检查是否合法
include
double x;
int main() {
std::cout << “enter!”;
while (!(std::cin >> x))
{
std::cout << “should double”;
std::cin.clear();
while (std::cin.get() != ‘\n’)
continue;
} std:: cout << “the value is” << x;
}
关于排列:定义一个描述三种颜色的枚举类型，编程输出这三种颜色的全排列
include
using namespace std;
enum color{red,blue,green};
enum color pri;
int n,i, j, k, loop;
int main()
{
n = 0;
for (i = red ;i <= green ;i++)
for (j = red; j <= green; j++) {
for (k = red; k <= green; k++)
if (i != j)
{
if ((k != i) && (k != j))
{
n++;
cout << n << “:”; for (loop = 1; loop <= 3; loop++)
{
switch (loop)
{
case(1):pri = (enum color)i; break;
case(2):pri = (enum color)j; break;
case(3):pri = (enum color)k; break;
}
switch (pri)
{
case(red):cout << "red "; break;
case(blue):cout << "blue "; break;
case(green):cout << "green "; break;
}
}
cout << endl;
}
}
}
关于将一个数组移位：先写一个函数向右移动一位，再写一个函数调用前面的函数移动n位
。#includeusing namespace std;
void move(int p[], int n)
{
int t;
t = p[n - 1];
if (n == 0) return;
for (int i = n-1; i > 0; i–)//注意i的取值
{
p[i] = p[i - 1];
}
p[0] = t;}
void movep(int p[], int k, int n)
{
for (int i = 0; i < k; i++)
move(p, n);//调用move函数移动k位
}
int main() {
int p[5];
int n;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> p[i];
}
for (int i = 0; i < n; i++)
{
cout << p[i];
}
int k;
cout << “the k:”;
cin >> k;
movep(p, k, n);
cout << “after:”;
for (int i = 0; i < n; i++)
cout << p[i];}
输入字符串，调用函数取出字符串中最长的单词并存入另一个字符串。
（有待思考)#define _CRT_SECURE_NO_WARNINGS
#include
#include
#includeusing namespace std;
void index(char* s1, char* s2)
{
int len ,max = 0;
char temp[50];
while (*s1)
{
while (*s1 == ’ ’ && *s1 != ‘\0’) s1++;//过滤空格；
len = 0;
while (*s1 != ' ' && *s1 != '\0')
{
*(temp + len) = *s1;//不能用*temp=*s1,why?
len++;
s1++;
}
*(temp + len) = '\0';//注意这种方式。
if (len > max)
{
max = len;
strcpy(s2, temp);
}
if (*s1 == '\0') break;
}}
int main()
{
char s1[50],s2[50];cin.get(s1,50); index(s1, s2);
cout << “s2:” << s2;
}用队列的方法输出杨辉三角：#include
using namespace std;
const int maxsize = 100;
typedef struct {
int Q[maxsize];//存放数据
int front, rear;
}sequeue;
sequeue qu;
void setkong(sequeue& qq)
{
qq.front = 0;
qq.rear = 0;
}//置队空
void rudui(sequeue& qq, int x)
{
if (qq.front == (qq.rear + 1) % maxsize)
cout << “overflow\n”;
else
{
qq.Q[qq.rear] = x;
qq.rear = (qq.rear + 1) % maxsize;
}
}
void chudui(sequeue &qq, int& x)
{
if (qq.front == qq.rear)
{
cout << “underflow\n”;
}
else
{
x = qq.Q[qq.front];
qq.front = (qq.front + 1) % maxsize;
}
}
void getfront(sequeue qq, int &x)//读取队头元素
{
if (qq.front == qq.rear)
{
cout << “error!\n”;
}
else
{
x = qq.Q[qq.front];
}
}
int empty(sequeue qq)//判断队列是否为空
{
if (qq.front == qq.rear)
return 1;
else
return 0;
}
void yanghui(int n,sequeue qu)
{
int i, j,s,t;
setkong(qu);
rudui(qu, 1); rudui(qu, 1);
cout << endl;
cout.width(4); cout << 1;
cout.width(4); cout << 1<<endl;
for (i = 2; i <= n; i++)//生成并输出杨辉三角第i~n行的数据
{
rudui(qu, 1);
cout.width(4); cout << 1;
chudui(qu, s);
for (j = 2; j <= i; j++)//处理第i行中间的各数据
{
chudui(qu, t);
rudui(qu, s + t);
cout.width(4); cout << s + t;
s = t;
}
rudui(qu, 1);
cout.width(4); cout << 1<<endl;
}
cout << endl;
}
int main()
{
int m;
cin >> m;
yanghui(m, qu);
}
最长的不重复的字符子串
include
#include
#include<unordered_set>
using namespace std;
int lengthOfLongestSubstring(string s);
int lengthOfLongestSubstring(string s)
{
// 哈希集合，记录每个字符是否出现过
unordered_set occ;
int n = s.size();
// 右指针，初始值为 -1，相当于我们在字符串的左边界的左侧，还没有开始移动
int rk = -1, ans = 0;
// 枚举左指针的位置，初始值隐性地表示为 -1
for (int i = 0; i < n; ++i)
{
if (i != 0)
{
// 左指针向右移动一格，移除一个字符
occ.erase(s[i - 1]);
}
while (rk + 1 < n && !occ.count(s[rk + 1]))
{
// 不断地移动右指针
occ.insert(s[rk + 1]);
++rk;
}
// 第 i 到 rk 个字符是一个极长的无重复字符子串
ans = max(ans, rk - i + 1);
}
return ans;
};
int main() {
string mm;
cin >> mm;
int num;
num = lengthOfLongestSubstring(mm);
cout << num;
}
彩票案例
（二维数组初始化)//彩票案例
//随机生成1-49之间的苏子 程序中每一组中按照升序排序
//检查某个数字在用户选择的所有彩票中出现的次数
//七行六列随机数
//注意初始化二维数组 int table = new int**[7]
//int table[i] = new int*[6]
//下标越界时会导致错误
#include
#include
#include
using namespace std;
const int column = 6;
const int maxx = 49;
void iniarray(int**, int);
int isnum(int**, int, int);
void sort(int**, int);
void print(int**);
int numoccur(int** table, int mm);
inline void memerror() {
cout << “error\n”;
exit(1);
}
void genloto(int**, int);
int main() {
int** table;
int numcheck;
int i;
int client;
char answer;
srand((unsigned)time(0));
table = new int* [7];
if (!table)
memerror();
for (i = 0; i < 7; i++) {
table[i] = new int[6];
if (!table[i])
memerror();//check for an allocation error
}
iniarray(table, 7);
genloto(table, 7);
for (i = 0; i < 7; i++)
{
sort(table, i);//sort numbers in a row
}
print(table);
cin >> client;//用户输入数字
numcheck = numoccur(table, client);
cout << "the num = " << numcheck;
}
void iniarray(inttable, int)
{
int i, j;
for (i = 0; i < 7; i++)
{
for (j = 0; j < 6; j++)
table[i][j] = 0;
}
}
void genloto(inttable, int)
{
int i, j;
int newnum;
for (i = 0; i < 7; i++) {
for (j = 0; j < 6; j++)
{
do
{
newnum = rand() % maxx + 1;
} while (isnum(table, i, newnum));
table[i][j] = newnum;
}
}
}
int isnum(int**table, int num, int n) {
for (int i = 0; i < 6; i++) {
if (table[num][i] == 0)
return 0;
if (table[num][i] == n)
return 1;
}
return 0;
}
//
升序排列的代码
void sort(int** table, int row) {
int temp;
for (int i = 0; i < 5; i++) {//注意i j 一定不能大于5
for (int j = 0; j < 5; j++)
{
if (table[row][j] > table[row][j + 1])
{
temp = table[row][j];
table[row][j] = table[row][j + 1];
table[row][j + 1] = temp;
}
}
}
}
void print(inttable)
{
cout << endl;
cout << "**\n";
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 6; j++)
cout << table[i][j] << “\t”;
cout << endl;
}
}
int numoccur(int table, int num) {
int count = 0;
for (int i = 0; i < 7; i++)
{
for (int j = 0; j < 6; j++)
{
if (table[i][j] == num)
count++;
}
}
return count;
}
银行账户管理系统
include
#include
using namespace std;
class saving {
private:
int id;
double balance;//余额
double rate;//年利率
int lastdate;//上次变更余额的时期
double accumulation;//余额按日期累加之和
void record(int date, double amount);
double accumulate(int date) const {
return accumulation + balance * (date - lastdate);
}
public:
saving(int date, int id, double rate);//构造函数
int getid() { return id; }
double getbalance() { return balance; }
double getrate() { return rate; }
void deposit(int date, double amount);//存入现金
void withdraw(int date, double amount);//取出现金
void settle(int date);//结算利息
void show();//显示账号信息
};
saving::saving(int date, int id, double rate):id(id),balance(0),rate(rate),lastdate(date),accumulation(0)
{
cout << id << “is created\n”;
}
void saving::record(int date, double amount)
{
accumulation = accumulate(date);
lastdate = date;
amount = floor(amount * 100 + 0.5) / 100; //保留小数点后两位
balance += amount;
cout << date << “—” << id <<“amount:”<< amount<<“balance:” << balance;
}
void saving::deposit(int date, double amount)
{
record(date, amount);
}
void saving:: withdraw(int date, double amount)
{
if (getbalance() < 0)
cout << “error\n”;
else
record(date, -amount);
}
void saving:: settle(int date)
{
double interest = accumulate(date) * rate / 365;
if (interest != 0)
record(date, interest);
accumulation = 0;
}
void saving::show()
{
cout << id << balance;
}
int main()
{
saving s1(1, 4234, 0.15);
s1.deposit(3, 5000);
s1.show();
s1.deposit(5, 3000);
cout << endl;
s1.show();
cout << endl;
s1.settle(80);
s1.show();
cout << endl;
}
容器嵌套#include
#include
#include
using namespace std;
void test()
{
vector<vector> mm;
vectorp1;
vectorp2;
vectorp3;
vectorp4;
for (int i = 0; i < 4; i++)
{
p1.push_back(i);
p2.push_back(i + 1);
p3.push_back(i + 2);
p4.push_back(i + 3);
}
mm.push_back(p1);
mm.push_back(p2);
mm.push_back(p3);
mm.push_back(p4);
for (vector<vector>::iterator mg = mm.begin(); mg != mm.end(); mg++)
{
for (vector<int>::iterator yj = (*mg).begin(); yj != (*mg).end(); yj++)
cout << *yj;
cout << endl;
}
}
int main()
{
test();
}
访问单个字符:string str = “hello”;for(int i = 0;i < str.size() ;i++)cout<<str[i];
多态性变步长梯形积分
include
class function//抽象类function的定义
{
public:
virtual double operator()(double x) const = 0;//纯虚函数重载运算符（）
virtual ~function() {};
};
class myfunction :public function {
public:
double operator()(double x) const;//覆盖虚函数
};
class integrate {
public:
virtual double operator()(double a, double b, double eps)const = 0;
virtual ~integrate() {}
};
class grate :public integrate {
public:
double operator()(double a, double b, double eps)const;
grate(function&mm):f(mm){}//构造函数
private:
function& f;//私有成员
};
//类实现
double myfunction::operator()(double x) const {
return log(1.0 + x) / (1.0 + x * x);
}
double grate::operator()(double a, double b, double eps)const
{
myfunction yy;
grate nice(yy);
bool judge = false;
double h = b - a;
double tn = (yy(a) + yy(b)) * h / 2;
double t2n;
int n = 1;
do{
double sum = 0;
for (int k = 0; k < n; k++) {
double x = a + (k + 0.5) * h;
sum += f(x);
}
t2n = (tn + h * sum) / 2.0;//变步长梯形法计算
if (fabs(t2n - tn) < eps)//判断积分误差
judge = true;
else
{
tn = t2n;
n *= 2;
h /= 2;
}
} while (!judge);
return t2n;
}
array类模板（重载指针下标运算符 等号）trap.h：动态数组类模板array
#include
template
class Array {
T* mm;//T类型指针 用于存放动态分配的数组首地址
int size;//数组大小
public:
Array(int siz = 50);
Array(const Array& yy);//复制构造函数
~Array();
Array& operator = (Array& rhs);//重载“=”
T& operator [](int i);//重载[];
operator T* ();
//重载指针转化运算符T* 要想对象名能像数组名一样使用下标，还要重载下标运算符
int getsize()const;
void resize(int sz);//修改数组大小
};
template
Array::Array(int siz)
{
assert(siz >= 0);
size = siz;
mm = new T[size];//动态分配size个T类型的元素空间
}
template
Array& Array:: operator = (Array& rhs)
//重载“=” 将对象rhs赋给本对象 实现对象之间整体赋值
{
if (size != rhs.size) {//如果本对象中数组大小与rhs不同 则删除数组原有内存然后重新分配
delete[]mm;//删除数组原有内存
size = rhs.size;//设置本对象数组大小
mm = new T[size];//重新分配size个元素的内存
}
for (int i = 0; i < size; i++)
{
mm[i] = rhs.mm[i];
}
return *this;//返回当前对象的引用
}
template
Array::~Array()
{
delete[]mm;
}
template
Array::operator T* ()
{
return mm;//返回当前对象中私有数组的首地址
}
template
T& Array:: operator [] (int i)
{
assert(i >= 0 && i < size);//检查下标是否越界
return mm[i];
}
template
int Array::getsize()const
{
return size;
}
template
void Array::resize(int sz)
{
assert(sz >= 0);//检查sz是否非负
if (size == sz)
return;//如果指定的大小与原有大小一样什么也不做
T* newlist = new T[sz];//申请新的内存
int n = (sz < size) ? sz : size;//将sz 与size中较小的值赋给n
for (int i = 0; i < n; i++)
{
newlist[i] = mm[i];//将原有数组的前n个元素复制到新数组中
}
delete[] mm;//删除原数组
mm = newlist;//使mm指向新数组
size = sz;//更新size
}
从键盘输入n，计算2~n中的质数并且输出
：#include
#include"trap.h"
#include
using namespace std;
int main()
{
int n;
cin >> n;
int count = 0;
Arraynice(10);
int i;
for (i = 2; i < n; i++)
{//检查i能否被比它小的质数整除
bool judge = true;
for (int j = 0; j < count; j++)//如果i被nice[j]整除说明i不是质数
{
if (i % nice[j] == 0)
{
judge = false;
break;
}
}
if (judge)
{
if (count == nice.getsize())//如果质数表满了将其空间加倍
nice.resize(count * 2);
nice[count++] = i;
}
}
for (i = 0; i < count; i++)
cout <<setw(8)<< nice[i];
}//个人认为a[0]一开始应该是一个随机数
vector构造函数//奇偶排序 先奇数再偶数 从大到小的顺序
#include
#include
#include
#include
#include
using namespace std;
int main()
{
istream_iterators1(cin), s2;//建立一对输入流迭代器
vector i1(s1, s2);//通过输入流迭代器从标准输入流中输入数据
sort(i1.begin(), i1.end());//将输入的整数排序
dequem1;
//循环遍历i1
for (vector::iterator ite = i1.begin(); ite != i1.end(); ++ite)
{
if (*ite % 2 == 0)//偶数放m1尾部
m1.push_back(*ite);
else
m1.push_front(*ite);
}
copy(m1.begin(), m1.end(), ostream_iterator(cout, “-”));//输出结果 以-符号分隔
}
结点类模板#include
using namespace std;
//结点类模板
template
class node {
private:
node* next;//指向后继结点的指针
public:
T data;//数据域
node(const T& data, node* next = 0);//构造函数
void insert(node* p);//在本结点之后插入一个同类结点
node* deleteafter();//删除本结点的后继结点并且返回其地址
node* getlocation();//获取后继结点的地址
const node* getlocation() const;//获取后继结点的地址
};
//类的实现部分
template
node::node(const T& data, node* next ):data(data),next(next){}
template
void node::insert(node* p)
{
p->next = next;//p的指针域指向当前结点的后继结点
next = p;//当前结点指针域指向p
}
template
nodenode:: deleteafter()
{
node temp;
temp = next;//将欲删除的结点地址存储在temp中
if (next == 0)//如果当前结点没有后继结点 返回空指针
return 0;
next = temp->next;//使当前结点指向temp的后继结点
return temp;//返回被删除的结点的地址
}
template
node* node::getlocation()
{
return next;//返回后继结点的指针
}
template
const node* node::getlocation() const
{
return next;
}
细胞分裂
:#include
#include
#include
#include
using namespace std;
const int maxx = 2000;
const int minn = 500;
class cell;
priority_queuecellque;
class cell {
private:
static int total;//细胞总数
int id;//当前细胞编号
int time;//细胞分裂时间
public:
cell(int birth) :id(total++) { time = birth + (rand() % (maxx - minn) )+ minn; }
//初始化获得细胞分裂时间
int getid() const{ return id; }//获取细胞编号
int gettime() const{ return time; }//获取细胞分裂时间
bool operator <(const cell& s)const { return time > s.time; }//定义"<"
void spilit()const
{
cell xibao1(time), xibao2(time);//得到两个细胞
cout << time << “cell” << id << “splits to” << xibao1.getid() << " " << xibao2.getid() << endl;
cellque.push(xibao1);//将第一个子细胞压入优先级队列
cellque.push(xibao2);//
}
};
int cell::total = 0;
int main()
{
srand(static_cast(time(0)));
int t;
cout << “input\n”;
cin >> t;
cellque.push(cell(0));
while (cellque.top().gettime() <= t)
{
cellque.top().spilit();
cellque.pop();
}
}
//栈操作#include
#include
using namespace std;
template<class T, int size = 50>
class stack {
private:
T list[size];
int top;
public:
stack();
void push(const T& mm){
assert(!isfull());//如果栈满了则报错
list[++top] = mm;//将新元素压入栈顶
}
T pop()//将栈顶元素弹出栈
{
assert(!isempty());
return list[top–];//返回栈顶元素并将其弹出栈
}
void clear()
{
top = -1;//清空栈
}
const T& peek()const//访问栈顶元素
{
assert(!isempty());//如果为空则报错
return list[top];
}
bool isempty()const
{
return top == -1;
}
bool isfull()const
{
return top == size - 1;
}
};
template<class T, int size>
stack<T, size>::stack() :top(-1) {};//构造函数 栈顶初始化为-1.class cal {
stacks;
void enter(double num)
{
s.push(num);
}//操作数弹出栈 如果栈中没有两个操作数则返回错误信息
bool gettwo(double& o1, double& o2)
{
bool mod;
if (s.isempty())
{
cout << “error”;
mod = false;
}
else
o1 = s.pop();
if (s.isempty())
mod = false;
else
{
o2 = s.pop();
mod = true;
}
}
void ope(char op)//连续将两个操作数弹出并放在o1和o2中 如果成功 执行运算并将结果压入栈
{
double oo1, oo2;
bool result = gettwo()}//执行由操作符op指定的运算
public:
void run()
void clear()
};