存取时间，指的是CPU读或写内存内数据的过程时间。
 
以读取为例，从CPU发出指令给内存时，便会要求内存取用特定地址的数据，内存响应CPU后便会将CPU所需要的数据送给CPU，一直到CPU收到数据为止，便成为一个读取的流程。
 
存储周期：连续启动两次读或写操作所需间隔的最小时间
 
内存的存取周期一般为60ns-120ns。单位以纳秒(ns)度量，换算关系1ns=10-6ms=10-9s，常见的有60ns、70ns、80ns、120ns等几种，相应在内存条上标为-6、-7、-8、-120等字样。这个数值越小，存取速度越快。
 

 
扩展资料
 
存储器的两个基本操作为“读出”与“写入”，是指将存储单元与存储寄存器(MDR)之间进行读写。存储器从接收读出命令到被读出信息稳定在MDR的输出端为止的时间间隔，称为“取数时间TA”。两次独立的存取操作之间所需最短时间称为“存储周期TMC”。半导体存储器的存取周期一般为6ns～10ns。
 
其中存储单元(memory location)简称“单元”。为存储器中存储一机器字或一字节的空间位置。一个存储器划分为若干存储单元，并按一定顺序编号，称为“地址”。如一存储单元存放一有独立意义的代码。即存放作为一个整体来处理或运算的一组数字，则称为“字”。
 
字的长度，即字所包含的位数，称为“字长”。如以字节来划分存储单元，则一机器字常须存放在几个存储单元中。存储单元中的内容一经写入，虽经反复使用，仍保持不变。如须写入新内容，则原内容被“冲掉”，而变成新写入的内容。
 
参考资料来源：百度百科——存取周期
 
参考资料来源：百度百科——存取时间

 
 
       众所周知，dat是一个类似加密的二进制格式文件，很多人喜欢将游戏数据保存在dat文件中，只有知道你的存放格式，才能够将数据破解出来，因而研究了dat文件的存取方式。其实就是c++文件的操作，只不过是在取的时候需要按照自己存放的格式获取出来。
 
 
 本文将实现将结构体数据保存到dat文件，并且将dat文件读取回来。
 
 
 1.struct结构体的格式数据
 
 
       首先定义一个结构体，用以存放存入dat文件的数据，同时，再取的时候按照结构体的格式进行获取操作：
 
 
 
  
 
   
#pragma once
#ifndef _STRUCT_H_
#define _STRUCT_H_

#include<vector>
#include <iostream>
#include <string>
using namespace std;;
#define MaxSize 10
//设置结构体的边界对齐为1个字节，对于结构体中的char数组，如果不满4的倍数字节，会默认补齐，声明之后数据在内存中是连续存储的。
#pragma pack(1) 
typedef struct _TEST_DAT
{
	int type;
	char name[MaxSize];
	int age;
}TESTDAT;

#pragma pack()

#endif 
  
 
 
 
  
 

   这时的结构体内存结构是对齐的。
 
 
 
 
 
 
 
 
 
 
 
 
 
2.TxtToFile存取dat文件
 
 
 
 
 
          先说存，首先初始化一个结构体，其次将该结构体数据依次保存到指定名字的dat文件中，如下：
 
 
 TxtToFile.h：
 
 
 
 
 
#pragma once
#ifndef _TXT_TO_FILE_H_
#define _TXT_TO_FILE_H_
#include<vector>
#include <iostream>
#include <fstream>
#include <string>
#include "Struct.h"
#include <stdio.h>
using namespace std;
class TxtToFile
{
public:
	TxtToFile();
	~TxtToFile();
	//外调函数,保存到dat文件
	bool  SaveToDat(string _datPath);
private:
	TESTDAT	m_dat;
	fstream	m_datstream;
	vector<TESTDAT>	m_getdat;

private:
	// 把基本的Number类型写入文件流中
	template<class T>
	bool Write(T value)
	{
		//re
		m_datstream.write(reinterpret_cast<char *>(&value), sizeof(T));
		return true;
	}
	//把字符串写入文件流
	void  WriteString(string _str, int	_count);
};
#endif
 
 
 TxtToFile.cpp
 ：
 
 
 
 
#include "stdafx.h"
#include "TxtToFile.h"
#include <sstream>

TxtToFile::TxtToFile()
{
	m_dat = TESTDAT{
		0,
		"dasdasd",
		1
	};
	
}


TxtToFile::~TxtToFile()
{
}
bool TxtToFile::SaveToDat(string _datPath)
{
	if (_datPath.size() == 0)
	{
		return false;
	}
	m_datstream.open(_datPath, fstream::out | fstream::binary);//以二进制的形式打开文件
	if (!m_datstream.is_open())
	{
		cout << "open" << _datPath << "Failed" << endl;
		m_datstream.close();
		return false;
	}
	Write(m_dat.type);//存入数据
	WriteString(m_dat.name, MaxSize);
	Write(m_dat.age);
	//Write(m_dat);
	cout << "Successed" << endl;
	m_datstream.close();
	return true;
}
void TxtToFile::WriteString(string _str, int _count)
{
	if (_str.length()>=_count)
	{
		cout << "write string error!" << endl;
		return;
	}
	m_datstream << _str;
	int len = _count - _str.length();
	while (len--)
	{
		m_datstream << '\0';
	}
}
 

 
 

 
 
         这个时候，已经把数据存入到dat文件中，接下来就是取数据了，如下：
 
首先在头文件中加两个函数：
 

 
 
 
  
 
 
  
  
	//从dat文件读取数据
	bool GetFromDat(string _datPath);
	__int64 getFileSize(const char *filename);

  
 cpp：
  
 
 
 
 
 
  
  
bool TxtToFile::GetFromDat(string _datPath)
{
	if (_datPath.size()==0)
	{
		return false;
	}
	
	__int64 scount = 0;
	__int64 stuctsize = sizeof(TESTDAT);
	TESTDAT testdat;
	__int64 filesize = getFileSize(_datPath.c_str());
	if (filesize==0|| filesize<stuctsize ||(filesize%stuctsize)!=0)
	{
		return false;
	}
	scount = filesize / stuctsize;

	FILE *inStream = NULL;
	const char* name = _datPath.c_str();
	inStream = fopen(name, "rb");
	if (inStream == NULL) return false;
	for (int i = 0; i < scount; i++)
	{
		//size_t fread(void *ptr, size_t size, size_t n, FILE *stream);
		//参数ptr是保存读取的数据，void*的指针可用任何类型的指针来替换，如char*、int *等等来替换；
		//size是每块的字节数；n是读取的块数，如果成功，返回实际读取的块数(不是字节数)，本函数一般用于二进制模式打开的文件中。
		fread(&testdat, stuctsize, 1, inStream);
		/*if (testdat.duration < 0)
		{
			fclose(inStream);
			return false;
		}*/
		m_getdat.push_back(testdat);
	}

	fclose(inStream);

	return true;
}

__int64 TxtToFile::getFileSize(const char *filename)
{
	__int64 size = 0;
	/*FILE *fp = fopen(filename, "rb");
	if (!fp)
	{
		return 0;
	}

	fseek(fp, 0, SEEK_END);
	size = ftell(fp);
	fseek(fp, 0, SEEK_SET);

	fclose(fp);*/
	fstream instreams;
	instreams.open(filename, ios::_Nocreate);
	if (!instreams.is_open())
	{
		return 0;
	}
	instreams.seekg(0, ios::end);
	size = instreams.tellg();
	instreams.close();
	return size;
}
读的时候用的是C语言的，因为映射一下就是结构体了，而且存的时候没有存空格\n\t之类的分隔符，所以用getline不好取。
 
 
 
3.测试样例
 
 
 
 
 
 main函数：
 
 
 
 
 
// DatTxt.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "TxtToFile.h"

int _tmain(int argc, _TCHAR* argv[])
{
	TxtToFile ttofile;
	ttofile.SaveToDat("Test.Dat");
	ttofile.GetFromDat("Test.Dat");
	return 0;
}


 
 
 
 运行视图：
 
 
 
 
 

  成功，并且能在目录下找到dat文件，如果要看取出来的数据，那么需要加断点查看咯
 
 
 
 
 
 
 Over

DataAutoAccess
 
自动存取Android Bundle中数据——给需要自动存取的变量添加注解，编译时会通过注解处理自动生成存取的代码
 
用处
 
Activity或Service启动时自动取出Intent中的数据，并赋值给相应的field
Activity或Fragment由于系统内存不足将要被杀死时，在onSaveInstanceState方法里存储数据，重启时在onCreate中取出数据并赋值给相应的field
 
使用
 
activity 中的使用：
 
public class ExampleActivity extends Activity{
    @AutoAccess String name;
    @AutoAccess String description;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //get data
        DataAutoAccess.getData(this, savedInstanceState);
        //TODO use fields...
    }

    @Override
    protected void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        //save data
        DataAutoAccess.saveData(this, outState);
    }
}
 
Intent传参形式：
 
Intent intent = new Intent(this, TestActivity.class);
intent.putExtra("name", "DataAutoAccess");
intent.putExtra("description", "Android bundle data auto access.");
startActivity(intent);
 
经过以上配置之后，DataAutoAccess会自动从intent中取出数据，给name和description变量赋值，而且当activity由于系统内存不足被杀死时，也会自动保存变量值，在onCreate时取出进行自动赋值。是不是感觉到挺Cool！
 
当然，实际使用过程中不会在每个activity都写一遍存取代码，所以可以把存取代码放在自己activity基类中，子activity只管数据的使用就可以，不需要关心数据存取。另外，DataAutoAccess的使用不局限于activity中，service和fragment中也可以使用，详细的使用和代码请前往Github DataAutoAccess。
 
项目代码
 
Github DataAutoAccess 
 
欢迎大家提议，我会继续优化，喜欢的就去github上star吧 O(∩_∩)O！
 
注：引用请注明作者

本文介绍了指针的一个使用技巧，可以通过此方法将单片机中的变量按字节保存到EEPROM中，也可以从EEPROM中还原一个多字节的整型数或者浮点数。
 
在内存中变量对整数类型，包括 
char, unsigned char, int, unsigned int, long, unsigned long 
多于一个字节的按低字节在前，高字节在后的顺序存储的，比如 
int iv = 0x1234,则在内存中的存储顺序，从地址由低到高的顺序排列，其值分别为: 34 12 
long lv = 0x11223344则在内存中的顺序为: 44 33 22 11 
如果想修改一个整型数的某个字节，则可以运用指针直接进行操作如下所示： 
unsigned char *puc; 
int i; 
long lv = 0x11223344; 
unsigned char temp[4]={0,0,0,0};
 
*puc = (unsigned char*)(&lv); 
for(i=0; i{ 
temp = *(puc+i); 
} 
运行后temp中的值则为temp[]={0x44, 0x33,0x22,0x11}; 
如果要修改一个数的值也可以直接用以上方法把赋值前后的操作数对调一下即可 
*(puc+i) = temp; 
即可通过*puc将temp中的单字节数转换为一个长整型数赋给 lv 
这种操作方法对数据的存储很有用，可以通过指针将长整型的数分别一个字节一个字节地写到文件中，读的时候按照同样的顺序再从文件中读到内存。当然在PC上也可以直接将长整型的数写到文件中，而在单片机中则只能一个字节一个字节地将数据写入到EEPROM中，通过这种指针操作就可以写到EEPROM中，或者读出整型或者浮点型数。以下为在ICCAVR中将数据写入到EEPROM和读出的程序。 
void EEPROMWriteLong( int addr,    // address in EEPROM 
      long dsrc)   // source data 
{ 
unsigned char *puc;
 
puc = (unsigned char*)(&dsrc); 
EEPROMWriteBytes(addr, (void*)puc, sizeof(long)); 
}     
 
long EEPROMReadLong( int addr) 
{ 
long res; 
unsigned char *puc = (unsigned char*)(&res); 
EEPROMReadBytes(addr, (void*)puc, sizeof(long)); 
return res; 
}
 
指针真是一个好东东，用好了就像一把无坚不摧锐利无比的长矛，但是用不好了可是会扎自己哦，这就是C的精华之民在吧！