Greenwicher's WikiAccelerated C++ 2016-04-19

#include <iostream>
int main(){
  std::cout<<"Hello, world!"<<std::endl;
  return 0;
}

#include <iostream>
int main(){
  std::cout<<"This (\") is a quote, and this (\\) is a backlash."<<std::endl;
  return 0;
}

#include <iostream>
int main(){
  std::cout<<"a\tbb\tccc\tdddd\teeeee\tffffff\t"<<std::endl;
  return 0;
}

#include <iostream>
int main(){
  std::cout<<"#include <iostream>\n int main(){\n std::cout<<\"Hello, world!\"<<std::endl;\n return 0;\n}"<<std::endl;
  return 0;
}

int main(){}

#include <iostream>
int
main()
{
std
::
cout
<<
"Hello, world!"
<<
std
::
endl
;
return
0
;
}

#include <iostream>
#include <string>
int main(){
  const std::string hello = "Hello";
  const std::string message = hello + ", world" + "!";
  std::cout << message << std::endl;
}

#include <iostream>
#include <string>
int main(){
  const std::string exclam = "!";
  const std::string message = "Hello" + ", world" + exclam;
  std::cout << message << std::endl;
}

#include <iostream>
#include <string>
int main(){
  { const std::string s = "a string";
    std::cout << s << std::endl;}
  { const std::string s = "another string";
    std::cout << s << std::endl;}
  return 0;
}

#include <iostream>
#include <string>
int main(){
  { const std::string s = "a string";
    std::cout << s << std::endl;
  { const std::string s = "another string";
    std::cout << s << std::endl;};}
  return 0;
}

#include <iostream>
#include <string>
int main(){
  { std::string s = "a string";
  { std::string x = s + ", really";
    std::cout << s << std::endl;
    std::cout << x << std::endl; }
    // std::cout << x << std::endl; // x is out of its scope here
  }
  return 0;
}

#include <iostream>
#include <string>
int main(){
  std::cout << "What is your name?";
  std::string name;
  std::cin >> name;
  std::cout << "Hello, " << name
	    << std::endl << "And what is yours?";
  std::cin >> name;
  std::cout << "Hello, " << name
	    << "; nice to meet you too!" << std::endl;
  return 0;
}

//不变式，到目前为止，在当前行中我们已经输出了c个字符
while (c != cols){
  if (r == 0 || r == rows -1 || c == 0 || c == cols -1){
    std::cout << "*";
    ++c;
  } else {
    //输出一个一个以上的非边界字符
    //修改c的值，保持不变式的真实性
  }
}

if (r == pad + 1 && c == pad + 1){
  std::cout << greeting;
  c += greeting.size();
} else {
  std::cout << " ";
  ++c;
}

for (init-statement condition; expression){
  statement
}

#include <iostream>
#include <string>

//生命我们使用的标准库名称
using std::cin; using std::endl;
using std::cout; using std::string;

int main(){
  //请求用户输入姓名
  cout << "Please enter your first name: ";

  //读入用户输入的姓名
  string name;
  cin >> name;

  //构造我们将要输出的信息
  const string greeting = "Hello, " + name + "!";

  //围住问候语的空白个数
  const int pad = 1;

  //待输出的行数与列数
  const int rows = pad * 2 + 3;
  const string::size_type cols = greeting.size() + pad * 2 + 2;

  //输出一个空百行，把输出和输入分隔开
  cout << endl;

  //输出rows行
  //不变式，到目前为止，我们已经输出了r行
  for(int r = 0; r != rows; ++r){
    string::size_type c = 0;

    //不变式，到目前为止，在当前行中我们已经输出了c个字符
    while (c != cols){
      //应该输出问候语了吗？
      if (r == pad + 1 && c == pad + 1){
	cout << greeting;
	c += greeting.size();
      } else {
	//我们是位于边界上吗？
	if (r == 0 || r == rows -1 ||
	    c == 0 || c == cols -1)
	  cout << "*";
	else
	  cout << " ";
	++c;
      }
    }
    cout << endl;
  }
  return 0;
}

#include <iostream>
#include <string>
using namespace std;
int main(){
  for(int i=10;i>=-5;--i){
    cout<<i<<endl;
  }
  return 0;
}

#include <iostream>
#include <string>
using namespace std;
int main(){
  int ans = 1;
  for(int i=1;i!=10;++i){
    ans *= i;
  }
  cout<<ans<<endl;
  return 0;
}

#include <iostream>
using namespace std;
int main(){
  int a,b;
  cout<<"Please enter two numders"<<endl;
  cin>>a>>b;
  int c = a>b ? a : b;
  cout<< c <<endl;
  return 0;
}

double x;
vector<double> homework;

//不变式：到目前为止，homework包含了所有读到的家庭作业成绩
while (cin >> x)
  homework.push_back(x);

#include <iomanip>
#include <ios>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using std::cin; using std::setprecision;
using std::cout; using std::string;
using std::endl; using std::streamsize;
using std::sort; using std::vector;
//using std::precision;

int main(){
  //请求输入并读入学生的姓名
  cout << "Please enter your first name: ";
  string name;
  cin >> name;
  cout << "Hello, " << name << "!" <<endl;

  //请求输入并读入期中和期末成绩
  cout << "Please enter your midterm and final exam grades: ";
  double midterm, final;
  cin >> midterm >> final;

  //请求输入家庭作业成绩
  cout << "Enter all your homework grades, "
	  "followed by end-of-file: ";

  //到目前为止，读到的家庭作业成绩的个数及总和
  int count = 0;
  double sum = 0;

  //把家庭作业成绩读到变量x中
  vector<double> homework;
  double x;

  //不变式：homework包含了所有的家庭作业成绩
  while (cin >> x)
    homework.push_back(x);

  //检查homework是否为空
  typedef vector<double>::size_type vec_sz;
  vec_sz size = homework.size();
  if (size == 0){
    cout << endl << "You must enter your grades. "
		 << "Please try again." << endl;
    return 1;
  }

  //对成绩进行排序
  sort(homework.begin(), homework.end());

  //计算家庭作业成绩的中值
  vec_sz mid = size / 2;
  double median;
  median = (size % 2 == 0) ? (homework[mid] + homework[mid-1]) / 2 : homework[mid];

  //输出结果
  streamsize prec = cout.precision();
  cout << "Your final grade is " << setprecision(3) << 0.2 * midterm + 0.4 * final + 0.4 * median << setprecision(prec) <<endl;

  return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
  vector<int> a;
  int x;

  while(cin>>x)
    a.push_back(x);
  sort(a.begin(),a.end());

  vector<int>::size_type size = a.size();
  vector<int>::size_type batchSize = size / 4;

  if (size % batchSize != 0){
    cout<<"The size of vector must be a multiple of 4."<<endl;
    return 1;
  }

  for(int i=size-1;i!=-1;--i){
    cout << a[i] << " ";
    if (i % batchSize == 0) cout<<endl;
  }

  return 0;
}

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main(){
  string x;
  vector<string> words;

  while(cin>>x)
    words.push_back(x);
  sort(words.begin(),words.end());

  vector<string>::size_type i = 0;
  string word = words[i];
  int count = 0;
  while(i<words.size()){
    if (words[i] != word){
      cout<<word<<": "<<count<<endl;
      count = 0;
      word = words[i];
    }
    count++;
    i++;
  }

  return 0;
}

#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main(){
  string x;
  int minL = 1000;
  int maxL = 0;
  while(cin >> x){
    int size = x.size();
    minL = minL<size ? minL : size;
    maxL = maxL>size ? maxL : size;
    cout << x << endl;
  }
  cout<<minL<<" "<<maxL<<endl;
  return 0;
}

#include <iomanip>
#include <ios>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using std::cin; using std::setprecision;
using std::cout; using std::string;
using std::endl; using std::streamsize;
using std::sort; using std::vector;

int main(){
  vector<string> names;
  vector<double> grades;
  int n,m;

  cin >> n >> m;
  for(int i=0; i<n; ++i){
    //请求输入并读入学生的姓名
    cout << "Please enter your first name: ";
    string name;
    cin >> name;
    names.push_back(name);
    cout << "Hello, " << name << "!" <<endl;

    //请求输入并读入期中和期末成绩
    cout << "Please enter your midterm and final exam grades: ";
    double midterm, final;
    cin >> midterm >> final;

    //请求输入家庭作业成绩
    cout << "Enter all your homework grades, "
	    "followed by end-of-file: ";

    //到目前为止，读到的家庭作业成绩的个数及总和
    int count = 0;
    double sum = 0;

    //把家庭作业成绩读到变量x中
    vector<double> homework;
    double x;

    //不变式：homework包含了所有的家庭作业成绩
    for(int j=0;j<m;++j){
      cin >> x;
      homework.push_back(x);
    }

    //检查homework是否为空
    typedef vector<double>::size_type vec_sz;
    vec_sz size = homework.size();
    if (size == 0){
      cout << endl << "You must enter your grades. "
		   << "Please try again." << endl;
      return 1;
    }

    //对成绩进行排序
    sort(homework.begin(), homework.end());

    //计算家庭作业成绩的中值
    vec_sz mid = size / 2;
    double median;
    median = (size % 2 == 0) ? (homework[mid] + homework[mid-1]) / 2 : homework[mid];

    double grade =  0.2 * midterm + 0.4 * final + 0.4 * median;
    grades.push_back(grade);

    //输出结果
    streamsize prec = cout.precision();
    cout << "Your final grade is " << setprecision(3) << grade << setprecision(prec) <<endl;

  }

  return 0;
}

//计算一个vector<double>类型的变量的中值
//值得注意的是，调用函数时整个vector参数都会被复制
double median(vector<double> vec){
  typedef vector<double>::size_type vec_sz;

  vec_sz size = vec.size();
  if (size == 0)
    throw domain_error("median of an empty vector");

  sort(vec.begin(), vec.end());

  vec_sz mid = size/2;

  return size % 2 == 0 ? (vec[mid] + vec[mid-1])/2 : vec[mid];
}

//根据期中、期末考试成绩和保存家庭作业的向量来计算学生的总成绩
//这个函数不用复制它的参数，因为median已经为我们完成了这个工作
double grade(double midterm, double final, const vector<double>& hw){
  if (hw.size() == 0)
    throw domain_error("student has done no homework");
  return grade(midterm, fianl, median(hw));
}

//从输入流中将家庭作业的成绩读入到一个vector<double>中
istream read_hw(istream& in, vector<double>& hw){
  if (in) {
    //清除原先的内容
    hw.clear();

    //读家庭作业成绩
    double x;
    while (in >> x)
      hw.push_back(x);

    //清楚流以使输入动作对下一个学生有效
    in.clear();
  }
  return in;
}

#include <iomanip>
#include <ios>
#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

using std::cin; using std::setprecision;
using std::cout; using std::string;
using std::endl; using std::streamsize;
using std::sort; using std::vector;
using std::domain_error; using std::istream;

double median(vector<double> vec){
  typedef vector<double>::size_type vec_sz;

  vec_sz size = vec.size();
  if (size == 0)
    throw domain_error("median of an empty vector");

  sort(vec.begin(), vec.end());

  vec_sz mid = size/2;

  return size % 2 == 0 ? (vec[mid] + vec[mid-1])/2 : vec[mid];
}

double grade(double midterm, double final, double homework){
  return 0.2 * midterm + 0.4 * final + 0.4 * homework;
}

double grade(double midterm, double final, const vector<double>& hw){
  if (hw.size() == 0)
    throw domain_error("student has done no homework");
  return grade(midterm, final, median(hw));
}

istream& read_hw(istream& in, vector<double>& hw){
  if (in) {
    //清除原先的内容
    hw.clear();

    //读家庭作业成绩
    double x;
    while (in >> x)
      hw.push_back(x);

    //清楚流以使输入动作对下一个学生有效
    in.clear();
  }
  return in;
}

int main(){
  //请求输入并读入学生的姓名
  cout << "Please enter your first name: ";
  string name;
  cin >> name;
  cout << "Hello, " << name << "!" <<endl;

  //请求输入并读入期中和期末成绩
  cout << "Please enter your midterm and final exam grades: ";
  double midterm, final;
  cin >> midterm >> final;

  //请求输入家庭作业成绩
  cout << "Enter all your homework grades, "
	  "followed by end-of-file: ";

  vector<double> homework;

  //读入家庭成绩作业
  read_hw(cin, homework);

  //如果可以的话，计算学生总成绩
  try{
    double final_grade = grade(midterm, final, homework);
    streamsize prec = cout.precision();
    cout << "Your final grade is " << setprecision(3)
	 << final_grade << setprecision(prec) << endl;
  } catch (domain_error){
    cout << endl << "You must enter your grades. "
	 << "Please try again." << endl;
    return 1;
  }

  return 0;
}

struct Student_info{
  string name;
  double midterm, final;
  vector<double> homework;
}; //注意这里的分号——它是不可缺少的

int main(){
  vector<Student_info> students;
  Student_info record;
  string::size_type maxlen = 0;

  //读并存储所有的记录，然后找出最长的姓名的长度
  while(read(cin, record)){
    maxlen = max(maxlen, record.name.size());
    students.push_back(record);
  }

  //按字母顺序排列记录
  sort(students.begin(), students.end(), compare);

  for(vector<Student_info>::size i = 0; i!= students.size(); ++i){
    //输出姓名，填充姓名以达到maxlen + 1的长度
    cout << setw(maxlen+1) << students[i].name;

    //计算并输出成绩
    try{
      double final_grade = grade(students[i]);
      streamsize prec = cout.precision();
      cout << setprecision(3) << final_grade << setprecision(prec);
    }catch(domain_error e){
      cout << e.what();
    }
  }
}

Student_info s;
std::string:size_type maxlen;
max(s.name.size(), maxlen);

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

int main(){
  const int n = 10; //change it to 999 for problem 4-3
  const int maxlen = floor(log10(n)) + 1; //calculate the digit length of n
  for(int i=1; i<=n; ++i){
    cout << left << setw(maxlen+1) << i << i*i <<endl;
  }
}

#include <iostream>
#include <iomanip>
#include <cmath>
using namespace std;

int main(){
  const double n = 10; //change it to 999 for problem 4-3
  const int maxlen = floor(log10(n)) + 1; //calculate the digit length of n
  for(double i=1; i<=n; ++i){
    cout << left << setw(maxlen+1) << i << i*i <<endl;
  }
}

#include <iostream>
#include <iomanip>
#include <string>
#include <vector>
using namespace std;

struct WordsInfo{
  string word;
  int num;
};

istream& read(istream& in, vector<string>& words, string::size_type& maxlen){
  string word;
  while(in >> word){
    maxlen = max(maxlen, word.size());
    words.push_back(word);
  }
  return in;
}

int count(const vector<string>& words, vector<WordsInfo>& wordsInfo){
  for(vector<string>::size_type i=0; i!=words.size(); ++i){
    bool flag = false;
    for(vector<WordsInfo>::size_type j=0; j!=wordsInfo.size(); ++j){
      if (words[i] == wordsInfo[j].word){
	wordsInfo[j].num++;
	flag = true;
	break;
      }
    }
    if (!flag){
      WordsInfo tmp;
      tmp.word = words[i];
      tmp.num = 1;
      wordsInfo.push_back(tmp);
    }
  }
  return 0;
}

bool compare(const WordsInfo& x, const WordsInfo& y){
 return x.word < y.word;
}

int write(const vector<WordsInfo>& wordsInfo, const string::size_type& maxlen){
  for(vector<WordsInfo>::size_type i=0; i!=wordsInfo.size(); ++i){
    cout << left << setw(maxlen+1) << wordsInfo[i].word << wordsInfo[i].num <<endl;
  }
  return 0;
}

int main(){
  string::size_type maxlen;
  vector<string> words;
  vector<WordsInfo> wordsInfo;

  read(cin, words, maxlen);
  count(words, wordsInfo);
  sort(wordsInfo.begin(), wordsInfo.end(), compare);
  write(wordsInfo, maxlen);
}

struct Student_info{
  string name;
  double grade;
};

#include <iostream>
#include <string>
#include <vector>
using namespace std;

int main(){
  vector<double> numbers;
  double number;
  double average;

  // read data, [1,2,3,4,5,6,7,8,9,10]
  while(cin >> number){
    numbers.push_back(number);
  }

  double sum = 0.0;
  for(vector<double>::size_type i=0; i!=numbers.size(); ++i){
    sum += numbers[i];
  }
  average = sum/numbers.size();
  cout << "The average of the vector is " << average << endl;
}

//第二次尝试：函数正确，不过可能会相当慢
vector<Student_info> extract_fails(vector<Student_info>& students){
  vector<Student_info> fail;
  vector<Student_info>::size_type i=0;
  //不变式：students的索引在[0,i)中的元素代表的成绩是及格的
  while(i != students.size()){
    if(fgrade(students[i])){
      fail.push_back(students[i]);
      students.erase(students.begin()+i);
    } else
      ++i;
  }
  return fail;
}

vector<Student_info>::const_iterator iter = students.begin();

for (vector<Student_info>::const_iterator iter = students.begin(); iter!= students.end(); ++iter) {
  cout << (*iter).name << endl;
}

// 如果参数是空白区域，返回true
bool space(char c){
  return isspace(c);
}
// 如果参数是空白区域，返回false
bool not_space(char c){
  return !isspace(c);
}
vector<string> split(const string& str){
  typedef string::const_iterator iter;
  vector<string> ret;

  iter i = str.begin();
  while(i != str.end){
    // 找到首个非空白字符迭代器
    i = find_if(i, str.end(), not_space);
    // 找到i之后首个空白字迭代器
    iter j = find_if(i, str.end(), space);
    // 复制[i, j)中的字符
    if (i != str.end())
      ret.push_back(string(i,j));
    i = j;
  }
  return ret;
}

bool is_palindrome(const string& s){
  return equal(s.begin(), s.end(), s.rbegin());
}
+ equal()
+ s.rbegin()

template <class T>
T median(vector<T> v){
  typedef typename vector<T>::size_type vec_sz;

  vec_sz size = v.size();
  if (size == 0)
    throw domain_error("median of an empty vector");

  sort(v.begin, v.end());

  vec_sz mid = size / 2;

  return size % 2 == 0 ? (v[mid] + v[mid-1]) / 2 : v[mid];
 }

template <class In, class X>
In find(In begin, In end, const X& x){
  while(begin != end && *begin != x)
    ++begin;
  return begin;
}

template <class In, class Out>
Out copy(In begin, In end, Out dest){
  while (begin != end)
    *dest++ = *begin++;
  return dest;
}

template <class For, class X>
void replace(For beg, For end, const X& x, const X& y){
  while(beg != end){
    if (*beg == x)
      *beg = y;
    ++beg;
  }
}

template <class Bi> void reverse(Bi begin, Bi end){
  while (begin != end){
    --end;
    if (begin != end)
      swap(*begin++, *end);
  }
}

template <class Ran, class X>
bool binary_search(Ran begin, Ran end, const X& x){
  while(begin < end){
    Ran mid = begin + (end - begin) / 2;
    if (x < *mid)
      end = mid;
    else if (*mid < x)
      begin = mid + 1
    else return true;
  }
  return false;
}

struct Student_info{
  std::string name;
  double midterm, final;
  std::vector<double> homewok;

  std::istream& read(std::istream&);
  double grade() const;
}

istream& Student_info::read(istream &in){
  in >> name >> midterm >> final;
  read_hw(in, homework);
  return in;
}

double Student_info::grade() const{
  return ::grade(midterm, final, homework);
}

class Student_info{
public:
  double grade() const;
  std::istream& read(std::istream&);
  std::string name() const {return n; }
private:
  std::string n;
  double midterm, final;
  std::vector<double> homewok;
}

bool compare(const Student_info&x, const Student_info& y){
  return x.name() < y.name();
}

class Student_info{
public:
  bool valid() const {return !homework.empty(); }
  // same as previous
}

Student_info::Student_info(): midterm(0), final(0) {}

Student_info::Student_info(istream& s) {read(is); }

#include<iostream>
using namespace::std;
int main(){
  int x = 5;
  int *p = &x;
  cout << "x=" << x << endl;
  *p = 6;
  cout << "x=" << x << endl;
  return 0;
}

int main(int argc, char ** argv){
  int fail_count = 0;
  for(int i = 1; i < argc; ++i){
    ifstream in(argv[i]);
    if (in){
      string s:
      while(getline(in, s))
	cout << s << endl;
    } else {
      cerr << "cannot open file" << argv[i] << endl;
      ++fail_count;
    }
  }
  return fail_count;
}

int* pointer_to_dynamic(int num){
  return new int(num);
}

int main(){
  int* p = pointer_to_dynamic(21);
  ++ *p;
  delete p;
  return 0
}

template <class T> class Vec{
public:
  Vec(const Vec& v){create(v.begin(), v.end()); }

}

template <classs T> class Vec{
public:
  Vec& operator=(const Vec&);
}

template <class T> clas Vec{
public:
  ~Vec() {uncreate(); }
}

class Str{
public:
  //构造函数同前
  char& operator[](size_type i){return data[i];}
  const char& operator[](size_type i) const {return data[i];}
private:
  Vec<char> data;
}

//这些代码还不能被编译通过
istream& operator>>(istream& is, Str& s){
  //抹去存在的值（s）
  s.data.clear();
  //按序读字符并忽略前面的空格
  char c;
  while (is.get(c) && isspace(c))
    ; //只判断循环条件，不进行其他工作
  //如果读到非空格字符，重复以上操作直到遇到一个空格字符
  if(is){
    do s.data.push_back(c); // 产生一个编译错误，因为data是私有成员数据
    while (is.get(c) && !isspace(c));
    //如果遇到一个空格字符，把它放在输入流的后面
    if (is)
      is.unget();
  }
  return is;
}

class Str{
public:
  Str& operator+=(const Str& s){
    std::copy(s.data.begin(), s.data.end(), std::back_inserter(data));
    return *this
  }
  //同前
};
Str operator+(const Str& s, const Str& t){
  Str r = s;
  r += t;
  return r
}

template <class T> class Handle {
public:
  Handle(): p(0) {}
  Handle(const Handle& s): p(0) {if (s.p) p = s.p->clone(); }
  Handle& operator=(const Handle&);
  ~Handle() {delete p;}

  Handle(T* t): p(t) {}

  operator bool() const {return p;}
  T& operator*() const;
  T* operator->() const;
private:
  T* p;
};
template<class T>
Handle<T>& Handle<T>::operator=(const Handle& rhs){
  if (&rhs != this){
    delete p;
    p = rhs.p ? rhs.p->clonse() : 0;
  }
  return *this;
}
template<class T>
T& Handle<T>::operator*() const{
  if (p)
    return *p;
  throw runtime_error("unbound Handle");
}
template<class T>
T* Handle<T>::operator->() const{
  if (p)
    return p;
  throw runtime_error("unbound Handle");
}