每天读一点C++Primer！

每天读一点点C++primer！半年读完就可以！

7/4

• 标准库定义了4个l0对象。为了处理输入，我们使用一个名为cin（发音为see-in）的istream类型的对象。这个对象也被称为标准输入（standardinput）。对于输出，我们使用一个名为cout（发音为see-out）的ostream类型的对象。此对象也被称为标准输出（standard output）。标准库还定义了其他两个ostream对象，名为cerr和clog（发音分别为see-err和see-log）。我们通常用cerr来输出警告和错误消息，因此它也被称为标准错误（standard error）。而clog用来输出程序运行时的一般性信息。
• IO对象无拷贝或者赋值
• 在函数参数括号写字符串被定义成const char *，最近经常碰到
• 局部静态对象只在第一次经过时初始化
• 当形参有顶层const时，传给它常量对象和非常量对象都是可以的
• 打算明天开始写项目多用指针和引用了，当时学算法不知道听了谁的鬼话尽量不用指针，结果现在还不熟。还是轮子哥说的靠谱。

8.1

#include <iostream>
#include <fstream>
#include <string>

using namespace std;
istream& task(istream &a) {

	string m;
	while (a >> m) {
		cout << m << endl;
	}
	a.clear();
	return a;

}
int main()
{
	std::filebuf in;
	if (!in.open("E:/GitCode/Messy_Test/testdata/istream.data", std::ios::in)) {
		std::cout << "fail to open file" << std::endl;
		return;
	}
	istream wss(&in);

	task(wss);

}

istream是所有输入类型的基类，直接cin调用即可。
6.2.1

#include "stdio.h"

void change(int* a, int* b) {
	int c = *a;
	*a = *b;
	*b = c;
}
int main() {
	int a, b;
	a = 1;
	b = 2;
	int* c = &a;
	int* d = &b;
	change(c, d);
	printf("a=%d b=%d",a,b);
}

6.2.2

#include "stdio.h"

void change(int& a, int& b) {
	int c = a;
	a = b;
	b = c;
}
int main() {
	int a, b;
	a = 1;
	b = 2;
	change(a, b);
	printf("a=%d b=%d", a, b);
}

6.2.3

#include "stdio.h"
#include <string>

std::string::size_type find_char(std::string& const s,char c,std::string::size_type &occurs) {
	auto ret = s.size();
	occurs = 0;
	for (decltype(ret)i = 0; i != s.size(); i++) {
		if (s[i] == c) {
			if (ret == s.size()) {
				ret = i;
			}
			++occurs;
		}
	}
	return ret;
}
int main() {
	std::string s = "sdafodsago";
	std::string::size_type ctr;
	auto index = find_char(s, 'o', ctr);
	
}

问题：我不明白一个课后问题，为什么std::string::size_type find_char(std::string& const s,char c,std::string::size_type &occurs)这个函数三个参数必须分别是现在的格式？或者说第一个参数用引用比不用引用好在哪里？（必须被定义为const的前提下）
明天打算重读引用那一章找出答案。

7/5

• 昨天问题的答案是：引用避免了新建对象，提高了速度
• 引用本身不是对象，不能定义引用的引用
• 如果你想要一个string形参能够接受常量，那么使用const；事实上，任何无需在函数中改变的字符串都应该被定义为常量引用

int *matrix[10];		//十个指针构成的数组
int (*matrix)[10];		//指向含有十个整数的数组的指针

• const cast用于改变const属性
• 一旦函数的某个形参被赋予了默认值，它后面的参数必须都有默认值
• 内敛函数可以在调用点内联展开，适用于优化流程直接规模小调用频繁的函数。
• constexpr函数是指能用于常量表达式的函数，它被隐式地指定为内联函数
• constexpr函数是指能用于常量表达式的函数：函数的返回值类型和所有形参的类型必须是“字面值类型”：算术、引用、指针。并且函数体内有且只有一条return语句。

6.2.4

#include "stdio.h"
#include<iostream>
#include<string>
using namespace std;
int function(int a,int *b,int *c) {
	std::cout<< *c++;
	std::cout << *c++;
	return 0;
}
void error_msg(initializer_list<string> il) {
	for (auto beg = il.begin(); beg != il.end(); beg++) {
		cout << *beg;
	}
}
void add(initializer_list<int> il) {
	int sum = 0;
	for (auto beg = il.begin(); beg != il.end(); beg++) {
		sum += *beg;
	}
	cout << sum;
}
int main(int argc, char **argv) {
	int a = 1,b = 2;
	int *c = &b;
	int j[2] = { 0,1 };
	//function(a, c,j);
	argv[0];
	//std::cout << argv[1] << argv[2];
	
}

6.3.2

#include "stdio.h"
#include<iostream>
#include<string>
using namespace std;

char &get_val(string &str, string::size_type ix) {
	return str[ix];
}

int main() {
	string s("a value");
	cout << s << endl;
	get_val(s, 0) = 'A';
	cout << s << endl;
	return 0;
}

#include "stdio.h"
#include<iostream>
#include<string>
#include<vector>
#include <cstdlib>
using namespace std;

char &get_val(string &str,string::size_type ix) {
	return str[ix];
}
int mainx() {
	return 100000;
}
vector<string> process() {
	return { "i","am","sb" };

}
int  (*func(int i))[10]{
	return 0;
}
//尾置返回类型
auto funcc(int i)->int(*)[10]{

}

//decltype
int odd[] = { 1,3,5,7,9 };
decltype(odd) *arrPtr(int i) {

}
string *testO(string &a) {

}

const string &shorterString(const string & s1, const string &s2) {
	return s1.size() <= s2.size() ? s1 : s2;
}
string &shorterString(string &s1, string& s2) {
	
}




int main() {
	string a[] = {"a","b","c"};
	testO(&a[]);

	string s("a value");
	cout << s << endl;
	get_val(s, 0) = 'A';
	cout << s << endl;
	return EXIT_FAILURE;


	return EXIT_SUCCESS;
}