c++ primer（第五版）笔记 第十二章 动态内存（2）

// 动态数组
#inlcude <memory>
#inlcude <string>

int main(){
// 分配要求数量的对象，返回第一个对象的指针
// []内必须是整型，不要求常量
// ()内为初始化值
int *p = new int[ 99]( 0);

// 可以分配大小为0 的动态数组,但不能解引用
int *p1 = new int[0];

// 动态数组的释放
// 释放动态数组时忘记[]，或释放单一对象时使用[]，行为未定义
delete [] p;
delete [] p1;

// 智能指针 unique_ptr 和动态数组
unique_ptr< int[]> upi ( new int[99]);
upi.release();	//自动释放

// 因为指向数组，所以不支持成员访问运算，可以使用下标
for( size_t i = 0; i != 99; ++i){
upi[i] = i;
}

// 如果使用 shared_ptr ，必须提供删除器
shared_ptr< int[]> spi ( new int[99], []( int *p){ delete [] p})
spi.reset();
// shared_ptr 不提供下标运算
for( size_t i = 0; i != 99; ++i){
*(spi.get() + i) = i;
}

// allocator 类定义于 memory 头文件中
// allocator 类及其算法
// allocator< T> a		定义一个 allocator 对象，可以为 T 类型的对象分配内存
// a.allocate( n)		分配一段未构造的内存，保存 n 个 T 类型的对象
// a.deallocate( p, n)	释放从 p 中地址开始的内存，p 是 allocate 返回的指针，n 为 p 创建时要求的大小，调用 deallocate 前必须对每个在此内存中的创建的对象调用 destroy
// a.construct( p, args)	p 是一个指向原始地址的指针， args 被传递给 T 类型的构造函数，用来在 p 指向的内存中构造一个对象
// a.destroy( p)		p 为 T* 类型的指针，此算法对 p 指向的对象执行析构函数

// 拷贝和填充未初始化内存的算法，定义于 memory 头文件中
// uninitialized_copy( b, e, b2)	从迭代器 b e 指定的范围内拷贝元素到迭代器 b2 制定的未初始化的原始内存中，b2 指向内存必须足够大，容纳所有拷贝
// uninitialized_copy_n( b, n, b2)	从迭代器 b 指向的元素开始，拷贝 n 个元素到 b2 开始的内存中
// uninitialized_fill( b, e, t)		在迭代器 b e 指定的原始范围中创建对象，对象的值均为 t 的拷贝
// uninitialized_fill_n( b, n, t)	在迭代器 b 指向的内存地址开始创建 n 个对象，b 必须足够大

return 1;
}

//query_result.h
#ifndef QUERYR_ESULT_H_
#define QUERY_RESULT_H_

#include <string>
#include <vector>
#include <set>
#include <iostream>
#include <memory>

class QueryResult{
using line_no = std::vector< std::string>::size_type;
friend std::ostream& print( std::ostream&, const QueryResult&);

public:
QueryResult( std::string s,
std::shared_ptr< std::set< line_no>> p,
std::shared_ptr< std::vector< std::string>> f):
word( s), lines( p), file( f) {}
private:
std::string word;
std::shared_ptr< std::set< line_no>> lines;
std::shared_ptr< std::vector< std::string>> file;
};

#endif	//QUERYRESULT_H_

// query_result.cc
#include "query_result.h"

std::ostream& print( std::ostream& os, const QueryResult& qr){
os << qr.word << " " << qr.lines->size() << " "
<<  "times" << std::endl;

for(auto num : *qr.lines){
os << "\t(line " << num + 1 << ") " << *(qr.file->begin() + num) << std::endl;
}
return os;
}

// text_query.cc
#ifndef TEXTQUERY_H_
#define TEXTQUERY_H_

#include <fstream>
#include <sstream>
#include <memory>
#include <vector>
#include <string>
#include <map>
#include <set>

class QueryResult;

class TextQuery{
public:
using line_no = std::vector< std::string>::size_type;

TextQuery( std::ifstream &);
QueryResult query( const std::string &) const;

private:
std::shared_ptr< std::vector< std::string>> line_array;		//input file
std::map< std::string, std::shared_ptr< std::set< line_no>>> word_map;	//a map :word  line_no
};

#endif	//TEXTQUERY_H_

// text_query.cc
#include "text_query.h"
#include "query_result.h"

TextQuery::TextQuery(std::ifstream &ifs){
std::string line;
while( getline( ifs, line)){		//从文件流中读取每一行
line_array->push_back( line);	//压入数据成员中
int n = line_array->size();		//行号

std::istringstream iss( line);		//字符串流
std::string word;
while(iss >> word){				//读取没个字符
auto &lines = word_map[ word];	//检索 map
if( !lines)
lines.reset( new std::set< line_no>);	//如果不存在，创建新动态内存
lines->insert( n);			//添加行号
}
}
}

QueryResult TextQuery::query( const std::string &word) const{
static std::shared_ptr< std::set< line_no>> nodata( new std::set< line_no>);
auto res = word_map.find( word);
if( res == word_map.end())
return QueryResult( word, nodata, line_array);
else
return QueryResult( word, res->second, line_array);
}

// search word in file
#include "text_query.h"
#include "query_result.h"
#include <fstream>

int main(){
std::ifstream ifs("test.txt");
TextQuery tp(ifs);
while( true){
std::cout << "enter a word to look for, or q ro quit: ";
std::string s;
if(!(cin >> s) || s == 'q')
break;
print( std::cout, tp.query(s)) << endl;
}
return 1;
}