打印练习

  1. #include <iostream>
  2. using namespace std;
  4. int main()
  5. {
  6.     std::cout << "Hello World!\n";
  9.     int i, j, k, f;
  10.     for (size_t i = 0; i < 4; i++)
  11.     {
  12.         for (size_t j = 0; j < 30; j++)
  13.         {
  14.             cout << " ";
  15.         }
  16.         for (size_t k = 0; k < 8-2*i; k++)
  17.         {
  18.             cout << " ";
  19.         }
  20.         for (size_t f = 0; f < 2*i; f++)
  21.         {
  22.             cout << "*";
  23.         }
  24.         cout << endl;
  25.     }
  26.     for (size_t i = 0; i < 3; i++)
  27.     {
  28.         for (size_t j = 0; j < 30; j++)
  29.         {
  30.             cout << " ";
  31.         }
  32.         for (size_t f = 1; f < 7; f++)
  33.         {
  34.             cout << "*";
  35.         }
  36.         cout << endl;
  37.     }
  39. }

测试闰年

  1. #include <iostream>
  2. using namespace std;
  4. int main()
  5. {
  6.     std::cout << "Hello World!\n";
  8.     int yearl;
  9.     bool isLeapYear;
  10.     cout << "Enter the year:";
  11.     cin >> yearl;
  12.     isLeapYear = (((yearl % 4 == 0) && (yearl % 100 != 0)) || (yearl % 400 == 0));
  13.     if (isLeapYear)
  14.     {
  15.         cout << yearl << " is a leap year" << endl;
  16.     }
  17.     else
  18.     {
  19.         cout << yearl << " is not a lear year" << endl;
  20.     }
  21. }

测试联合体

  1. std::cout << "Hello World!\n";
  3.     aa.uu.x = 4;
  4.     aa.uu.y = 5;
  5.     aa.uu.z = 6;
  7.     aa.k = 0; //覆盖掉第一个int空间值
  9.     printf("d% d% d% d%\n", aa.uu.x, aa.uu.y, aa.uu.z, aa.k);

随机掷骰子

  1. #include <iostream>
  2. #include<stdio.h>
  3. #include<cstdlib>
  5. using namespace std;
  7. int rolldice();
  8. int main()
  9. {
  10.     std::cout << "Hello World!\n";
  12.     int flag;
  13.     unsigned seed;
  14.     cout << "请输入无符号整数：" << endl;
  15.     cin >> seed;
  17.     srand(seed);
  18.     int sum = rolldice();
  19.     int selfdim;
  20.     switch (sum)
  21.     {
  22.     case 7:
  23.     case 11:
  24.         flag = 1;
  25.         break;
  27.     case 2:
  28.     case 3:
  29.     case 12:
  30.         flag = 2;
  31.         break;
  33.     default:
  34.         flag = 0;
  35.         selfdim = sum;
  36.         break;
  37.     }
  39.     while (flag == 0)
  40.     {
  41.         sum = rolldice();
  42.         if (sum == selfdim)
  43.         {
  44.             flag = 1;
  45.         }
  46.         else if (sum = 7)
  47.         {
  48.             flag = 2;
  49.         }
  50.     }
  51.     if (flag == 1)
  52.     {
  53.         cout << "player win\n";
  54.     }
  55.     else
  56.     {
  57.         cout << "player lose\n";
  58.     }
  59. }
  60. int rolldice()
  61. {
  62.     int sum = 0;
  63.     int dim1 = rand() % 6 + 1;
  64.     int dim2 = rand() % 6 + 1;
  65.     sum = dim1 + dim2;
  66.     cout << "sum=" << dim1 << "+" << dim2 << endl;
  67.     return sum;
  68. }

递归

  1. #include <iostream>
  2. #include<stdio.h>
  3. #include<cstdlib>
  5. using namespace std;
  7. int f(int n);
  8. int main()
  9. {
  10.     std::cout << "Hello World!\n";
  11.     std::cout << "input x!\n";
  12.     int x;
  13.     cin >> x;
  14.     cout << f(x) << endl;
  15.     return 0;
  17. }
  18. int f(int n)
  19. {
  20.     if (n==0)
  21.     {
  22.         return 1;
  23.     }
  24.     else
  25.     {
  26.         return n * f(n - 1);
  27.     }
  28. }

内联函数

  1. #include <iostream>
  2. #include<stdio.h>
  3. #include<cstdlib>
  5. using namespace std;
  7. //函数声明
  8. inline double CalArea(double radius);
  9. int main()
  10. {
  11.     std::cout << "Hello World!\n";
  13.     double r(3.0);
  14.     double area;
  15.     area = CalArea(r);
  16.     cout << area << endl;
  17.     return 0;
  18. }
  19. //加关键字inline
  20. inline double CalArea(double radius)
  21. {
  22.     return 3.14 * radius * radius;
  24. }

综合练习(类等)

  1. #include <iostream>
  2. #include<stdio.h>
  3. #include<cstdlib>
  5. using namespace std;
  6. const float PI = 3.14159;
  7. const float FencePrice = 35;
  8. const float ConcretPrice = 20;
  10. class Circle
  11. {
  12. public:
  13.     Circle(float r);
  14.     ~Circle();
  15.     float Circumference() const;
  16.     float Area() const;
  18. private:
  19.     float radious;
  20. };
  22. Circle::Circle(float r)
  23. {
  24.     radious = r;
  25. }
  27. Circle::~Circle()
  28. {
  29. }
  31. float Circle::Circumference() const
  32. {
  33.     return PI * 2 * radious;
  34. }
  35. float Circle::Area() const
  36. {
  37.     return PI * radious * radious;
  38. }
  41. int main()
  42. {
  43.     std::cout << "Hello World!\n";
  45.     cout << "请输入游泳池半径\n";
  47.     float radius;
  48.     float FenceCost, ConcretCost;
  49.     cin >> radius;
  51.     Circle    circle(radius);
  52.     Circle    circle2(radius+3);
  54.     // 计算栅栏造价并输出
  55.     FenceCost = circle.Circumference() * FencePrice;
  56.     cout << "Fencing Cost is ￥" << FenceCost << endl;
  57.     ConcretCost = (circle2.Area() - circle.Area()) * ConcretPrice;
  58.     cout << "Concrete Cost is ￥" << ConcretCost << endl;
  63.     return 0;
  65. }

常对象

  3. //main.cpp
  4. #include<iostream>
  6. using namespace std;
  9. class AA
  10. {
  11. public:
  12.     AA();
  13.     ~AA();
  15.     AA(int r1, int r2) { R1 = r1; R2 = r2; }
  16.     //const区分成员重载函数
  17.     void print();
  18.     void print() const;
  20. private:
  21.     int R1, R2;
  22. };
  24. AA::AA()
  25. {
  26. }
  28. AA::~AA()
  29. {
  30. }
  33. void AA::print()
  34. {
  35.     cout << "普通调用" << endl;
  36.     cout << R1 << ":" << R2 << endl;
  37. }
  38. //实例化也需要带上
  39. void AA::print() const
  40. {
  41.     cout << "常对象调用" << endl;
  42.     cout << R1 << ";" << R2 << endl;
  43. }
  45. int main() {
  46.     AA a(5, 4);
  47.     a.print();  //调用void print()
  48.     //通过常对象只能调用它的常成员函数
  49.     const AA b(20, 52);
  50.     b.print();  //调用void print() const
  52.     return 0;
  54. }

重载运算符()

  1. #include <iostream>
  2. using namespace std;
  3. class Time
  4. {
  5. public:
  6.     Time();
  7.     ~Time();
  8.     Time(int h = 0, int m = 0, int s = 0) :hh(h), mm(m), ss(s) {}
  9.     void operator() (int h, int m, int s) {
  10.         hh = h;
  11.         mm = m;
  12.         ss = s;
  14.     }
  15.     void ShowTime()
  16.     {
  17.         cout << hh << ":" << mm << ":" << ss << endl;
  18.     }
  21. private:
  22.     int hh, mm, ss;
  23. };
  25. Time::Time()
  26. {
  27. }
  29. Time::~Time()
  30. {
  31. }
  33. int main()
  34. {
  35.     Time t1(12, 12, 33);
  36.     t1.ShowTime();
  37.     t1.operator()(33, 34, 56);
  38.     t1.ShowTime();
  39.     t1(23, 43, 56);
  40.     t1.ShowTime();
  43.     return 0;
  44. }

抽象类

  1. #include <iostream>
  2. using namespace std;
  3. class Figure
  4. {
  5. public:
  6.     Figure();
  7.     ~Figure();
  9.     void set(double i, double j) {
  10.         x = i;
  11.         y = j;
  12.     }
  14.     virtual void area() = 0;
  15. private:
  17. protected:
  18.     double x, y;
  19. };
  21. Figure::Figure()
  22. {
  23. }
  25. Figure::~Figure()
  26. {
  27. }
  30. class Triangle:public Figure
  31. {
  32. public:
  33.     Triangle();
  34.     ~Triangle();
  36.     void area() {
  37.         cout << "三角形面积:" << x * y * 0.5 << endl;
  38.     }
  39. private:
  41. };
  43. Triangle::Triangle()
  44. {
  45. }
  47. Triangle::~Triangle()
  48. {
  49. }
  50. class Rectangle:public Figure
  51. {
  52. public:
  53.     Rectangle();
  54.     ~Rectangle();
  56.     void area() {
  57.         cout << "矩形面积:" << x * y * 1 << endl;
  58.     }
  59. private:
  61. };
  63. Rectangle::Rectangle()
  64. {
  65. }
  67. Rectangle::~Rectangle()
  68. {
  69. }
  71. int main()
  72. {
  73.     Figure* fg = nullptr;
  74.     Rectangle r;
  75.     Triangle t;
  76.     t.set(2, 3);
  77.     fg = &t;
  78.     fg->area();
  80.     r.set(3, 5);
  81.     fg = &r;
  82.     fg->area();
  84.     Figure &rrf = t;
  85.     rrf.set(4, 5);
  86.     rrf.area();
  87. }

重载() []

  1. #include<iostream>
  2. using namespace std;
  3. class X
  4. {
  5. public:
  6.     int operator() (int i = 0)
  7.     {
  8.         cout << "X::operator(" << i << ")" << endl; return i;
  9.     };
  10.     int operator() (int i, int j)
  11.     {
  12.         cout << "X::operator(" << i << "," << j << ")" << endl;
  13.         return i;
  14.     };
  15.     int operator[] (int i)
  16.     {
  17.         cout << "X::operator[" << i << "]" << endl; 
  18.         return i;
  19.     };
  20.     int operator[] (  char* cp) 
  21.     {
  22.         cout << "X::operator[" << cp << "]" << endl; 
  23.         return 0;
  24.     };
  25. };
  26. int main(void)
  27. {
  28.     X obj;    
  29.     char data[] = "ass";
  30.     int i = obj(obj(1), 2);
  31.     int a = obj[i];    
  32.     int b = obj[data];
  33.     cout << "a=" << a << endl;
  34.     cout << "b=" << b << endl;
  35.     //system("pause");
  36. }

[] 实战

  1. #include<iostream>
  2. #include<cstring>
  3. #include<cstdio>
  5. using namespace std;
  6. struct Person {
  7.     double salary;
  8.     char *name;
  9. };
  11. class SalaryManager {
  12. public:
  13.     SalaryManager();
  15.     ~SalaryManager();
  17.     SalaryManager(int Max = 0) {
  18.         max = Max;
  19.         n = 0;
  20.         employ = new Person[max];
  21.     }
  23.     double &operator[](char *Name)//重载[],返回引用
  24.     {
  25.         Person *p;
  26.         for (p = employ; p < employ + n; p++) {
  27.             //如果存在则处理
  28.             if (strcmp(p->name, Name) == 0) {
  29.                 return p->salary;
  30.             }
  32.         }
  33.         p = employ + n++;
  34.         p->name = new char[strlen(Name) + 1];
  35.         strcpy(p->name, Name);
  36.         p->salary = 0;
  37.         return p->salary;
  39.     }
  41.     void display() {
  42.         for (int i = 0; i < n; i++) {
  43.             cout << employ[i].name << "   " << employ[i].salary << endl;
  44.         }
  45.     }
  47. private:
  48.     Person *employ;//存放职工信息的数组
  49.     int max;        //数组下标上界
  50.     int n;        //数组中的实际职工人数
  51. };
  53. SalaryManager::SalaryManager() {
  54. }
  56. SalaryManager::~SalaryManager() {
  57. }
  59. int main() {
  60.     SalaryManager s(3);
  61.     s["张三"] = 2323;
  62.     s["李四"] = 34343;
  63.     s["王五"] = 3432;
  65.     cout << "zhangsan\n" << s["张三"] << endl;
  66.     cout << "lisi\n" << s["李四"] << endl;
  68.     s.display();
  69. }

线程1 (范围锁,等待,唤醒)

  1. #include <iostream>                // std::cout
  3. #include <thread>                // std::thread
  5. #include <mutex>                // std::mutex, std::unique_lock
  7. #include <condition_variable>    // std::condition_variable
  11. std::mutex mtx; // 全局互斥锁.
  13. std::condition_variable cv; // 全局条件变量.
  15. bool ready = false; // 全局标志位.
  19. void do_print_id(int id)
  21. {
  22.     std::cout << "thread " << id << "start"<<'\n';
  25.     std::unique_lock <std::mutex> lck(mtx);
  27.     while (!ready) // 如果标志位不为 true, 则等待...
  29.         cv.wait(lck); // 当前线程被阻塞, 当全局标志位变为 true 之后,
  31.     // 线程被唤醒, 继续往下执行打印线程编号id.
  33.     std::cout << "thread " << id << '\n';
  35. }
  39. void go()
  41. {
  43.     std::unique_lock <std::mutex> lck(mtx);
  45.     ready = true; // 设置全局标志位为 true.
  47.     cv.notify_all(); // 唤醒所有线程.
  49. }
  53. int main()
  55. {
  57.     std::thread threads[10];
  59.     // spawn 10 threads:
  61.     for (int i = 0; i < 10; ++i)
  63.         threads[i] = std::thread(do_print_id, i);
  67.     std::cout << "10 threads ready to race...\n";
  69.     go(); // go!
  73.   for (auto & th:threads)
  75.         th.join();
  79.     return 0;
  81. }

线程2 生产者消费者问题

  1. #include<iostream>
  2. #include<deque>
  3. #include<thread>
  4. #include<mutex>
  5. #include<condition_variable>
  6. #include<windows.h>
  8. using namespace std;
  10. deque<int> q;
  11. mutex mu;//锁机制
  12. condition_variable cond;//通信用的条件变量
  13. int c=0;//缓冲区的产品个数
  15. void producer()
  16. {
  17.     int data1;
  18.     while (true) {
  19.         if(c<3)     //限流
  20.         {
  21.             data1=rand();
  22.             unique_lock<mutex> lck(mu); //锁
  23.             q.push_front(data1);
  24.             cout<<"存了"<<data1<<endl;
  25.             cond.notify_one();  //通知取
  26.             ++c;
  27.         }
  28.         Sleep(500);
  29.     }
  30. }
  32. void    consumer()
  33. {
  34.     int data2;  //data用来覆盖存放取的数据
  35.     while(true)
  36.     {
  37.         unique_lock<mutex>  locker(mu);
  38.         while (q.empty()) {
  39.             cond.wait((locker));        //wait()阻塞前会先解锁,解锁后生产者才能获得锁来把产品放到缓冲区;生产者notify后,将不再阻塞,且自动又获得了锁.
  40.                                         //线程在 condition_variable上等待时，会释放已持有的锁，直至被唤醒后（此时队列非空）重新获取锁。
  41.         }
  42.         data2=q.back();     //取的第二步
  43.         cout<<"got "<<data2<<endl;
  44.         --c;
  45.     }
  46.     Sleep(1500);
  47. }
  49. int main()
  50. {
  51.     thread t1(producer);
  52.     thread t2(consumer);
  54.     t1.join();
  55.     t2.join();
  57.     return 0;
  58. }

随机数

  1. #include<iostream>
  2. #include<vector>
  3. #include<random>
  6. using namespace std;
  7. using my_engine= default_random_engine;    //引擎类型
  8. using my_distribution= uniform_int_distribution<>;    //分布类型
  10. class Rand_int
  11. {
  12. public:
  13.     Rand_int(int low, int high):dist(low, high){}
  14.     int operator()(){return dist(re);}
  16. private:
  17.     default_random_engine re;
  18.     uniform_int_distribution<> dist;
  19. };
  22. int main()
  23. {
  24.     Rand_int rnd{0,4};        //创建一个随机数生成器
  25.     vector<int> histogram(5);        //构建一个相应尺寸的vector
  26.     for(int i=0;i!=200;++i)
  27.     {
  28.         ++histogram[rnd()];            //用[0:4]之间的每个数字出现的次数填充histogram
  30.     }
  33.     for(int i=0;i!=histogram.size();++i)
  34.     {
  35.         cout<<i<<'\t';
  36.         for(int j=0;j!=histogram[i];++j)
  37.             cout<<'*';
  38.         cout<<endl;
  39.     }
  41. }

线程 future(有问题,乱码)

  1. #include <iostream>
  2. #include <thread>
  3. #include <mutex>
  4. #include<future>
  5. #include<Windows.h>
  6. using namespace std;
  7. double t1(const double a, const double b)
  8. {
  9.  double c = a + b;
  10.  Sleep(3000);//假设t1函数是个复杂的计算过程，需要消耗3秒
  11.  return c;
  12. }
  14. int main()
  15. {
  16.  double a = 2.3;
  17.  double b = 6.7;
  18.  future<double> fu = async(t1, a, b);//创建异步线程线程，并将线程的执行结果用fu占位；
  19.  cout << "waiting..." << endl;
  20.  cout << "wait a moment" << endl;
  22.  cout<<a<<"+"<<b<<"="<<endl;
  23.  cout << "result：" << fu.get() << endl;//阻塞主线程，直至异步线程return
  24.         //cout << "计算结果：" << fu.get() << endl;//取消该语句注释后运行会报错，因为future对象的get()方法只能调用一次。
  25.  return 0;
  26. }