glide源碼解析
① 用C++設計一個發工資程序
按照題目要求編寫的C++程序如下
(見圖,代碼麻煩你自己打一下)
② 安卓開發需要學什麼
安卓開發需要學：
一、應用程序
Android以Java為編程語言，使介面到功能，都有層出不窮的變化，其中Activity等同於J2ME的MIDlet，一個 Activity 類負責創建視窗，一個活動中的Activity就是在 foreground（前景）模式，背景運行的程序叫做Service。
二、中介軟體
操作系統與應用程序的溝通橋梁，並用分為兩層：函數層（Library）和虛擬機（Virtual Machine）。 Bionic是 Android 改良libc的版本。
Android 同時包含了Webkit，所謂的Webkit 就是Apple Safari瀏覽器背後的引擎。Surface flinger 是就2D或3D的內容顯示到屏幕上。Android使用工具鏈(Toolchain)為Google自製的Bionic Libc。
三、硬體抽像層
Android 的 HAL（硬體抽像層）是能以封閉源碼形式提供硬體驅動模塊。HAL
的目的是為了把 Android framework 與 Linux kernel 隔開。
讓 Android 不至過度依賴 Linux
kernel，以達成 kernel independent 的概念，也讓 Android framework
的開發能在不考量驅動程序實現的前提下進行發展。
四、編程語言
Android 是運行於 Linux kernel之上，但並不是GNU/Linux。因為在一般GNU/Linux 里支持的功能，Android 大都沒有支持。
包括Cairo、X11、Alsa、FFmpeg、GTK、Pango及Glibc等都被移除掉了。Android又以bionic 取代Glibc、以Skia 取代Cairo、再以opencore 取代FFmpeg 等等。
五、安全控制
目前Android 的 Linux kernel控制包括安全（Security），存儲器管理（Memory Managemeat），程序管理（Process Management），網路堆棧（Network Stack），驅動程序模型等。
下載Android源碼之前，先要安裝其構建工具Repo來初始化源碼。Repo 是 Android 用來輔助Git工作的一個工具。
參考資料來源：網路—android開發
③ android開發一般都使用什麼框架
千夏軟體（www.qianxx.com）認為，目前框架使用的主要都是開源框架，都可以在github上找到：
1、volley，項目
2、android-async-http 項目
3、Afinal框架 項目
4、xUtils框架 項目
5、ThinkAndroid 項目
6、LoonAndroid 項目
主要有以下模塊：
(1) 自動注入框架（只需要繼承框架內的application既可）
(2) 圖片載入框架（多重緩存，自動回收，最大限度保證內存的安全性）
(3) 網路請求模塊（繼承了基本上現在所有的http請求）
(4) eventbus（集成一個開源的框架）
(5) 驗證框架（集成開源框架）
(6) json解析（支持解析成集合或者對象）
(7) 資料庫（不知道是哪位寫的 忘記了）
(8) 多線程斷點下載（自動判斷是否支持多線程，判斷是否是重定向）
(9) 自動更新模塊
(10) 一系列工具類
④ glide怎麼和activity綁定生命周期的
其實Glide與activity和fragment綁定生命周期很簡單,只用在with的時候傳入想綁定生命周期的Context就行.
比如通常在MainActivity中傳入this,或者MainActivity即可
(在Glide內部會根據你Context的實際類型做不同的處理,具體的分析會在以後的源碼分析中展示)
Glide.with(this).load(mUrl).into(mIv);
⑤ android面試看過哪些源碼
網路庫volley，OkHttp，Retrofit，圖片庫Universal Image Loader、Glide、非同步載入庫RxJava、熱修復庫Tinker等等，把項目中用到的第三方庫看看就行了。
⑥ 安卓開發需要學習什麼
學習分三個階段：
1，Android基礎階段：平台架構特性(JAVA/C) Market/應用程序組件 環境搭建與部署/打包與發布 AVD/DDMS/AAPT 調試與測試 相關資源訪問/資源製作 Activity/Service/Broadcast Receiver/Content Provider/原理(生命周期)及深層實現
2，Android進階初級：組件Widget/ 菜單Menu/ 布局Layout 詳解 Xml解析(Pull/Dom/Sax)/JNI 解析SQL資料庫原理,。
SQLite /SharedPreferences/File詳解 多媒體Audio/Video/Camera 詳解
3，Android進階高級：藍牙/WIFI SMS/MMS 應用實現 深層次解析GPS原理。
實現LocationManager/LocationProvider 進行定位/跟蹤/查找/趨近警告以及Geocoder正逆向編解碼等技術細節 2D圖形庫(Graphics/View)詳解 SDCARD/感測器/手勢 應用實現
(6)glide源碼解析擴展閱讀：
知識體系
1、Unix/Linux平台技術：基本命令，Linux下的開發環境
2、企業級資料庫技術：SQL語言、SQL語句調優、Oracle資料庫技術
3、Java 語言核心技術：Java語言基礎、Java面向對象編程、JDK核心API、Java集合框架、Java網路編 程、JavaI/O編程、Java多線程編程、Java異常機制、Java安全、JDBC、XML
4、軟體工程和設計模式：軟體工程概述、配置管理及SVN、UML、基本設計模式
5、Android應用開發基礎：Android開發平台、Eclipse+ADT開發環境、AVD及感測模擬器調試、Android核心組件、Android常用組件、Android高級組件、文件及網路訪問、SQLite資料庫編程、後台服務編程
6、互聯網核心技術： HTML、CSS、JavaScript、JQuery、Ajax應用
7、Android高級應用開發：音頻視頻攝像頭、互聯網應用、GPS和位置服務、Google Map、2D3D繪制、感測器開發、游戲開發、電話及SMS服務、網路BluetoothWi-Fi等。
8、Android系統級開發：移植、驅動、NDK（C方向）。
9、JavaEE核心技術：Servlet核心技術、JSP核心技術、Struts、Spring、Hibernate框架。
⑦ 哪位大哥能給我一個基於IDEA演算法的c或者c++的軟體以及源代碼啊
c++ code
////////////////////////////////////////////////////////
//
// Project: Implementation of IDEA (International
// Data Encryption Algorithm)
//
// ECE 575 Term Project
// Winter 2003
// Author: Irwin Yoon
//
// Overview: This code does the following:
// - print out all encryption and
// decryption subkeys which are used
// in the encryption and decryption
// process
// - encrypts plaintext message
// - decrypts ciphertext message
// - shows detailed, round by round results
// (8 total)
// Program contains a user driven menu where the user can select
// initial 128-bit key and also select messages to decrypt
// and encrypt.
//
// Compiling: This has been verified to work on SunOS
// with g++ compiler (flop.engr.orst.e).
// To Compile: g++ Idea.cpp -o Idea.exe
//
// Note: This code is a little sloppy. Coding could
// be made more efficient.
//
// Usage: Run executable with no arguments: Idea.exe
// Then select appropriate menu options
//
//
//
//////////////////////////////////////////////
// main() is at the bottom of file!
#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <cassert>
#include <string>
//globals
#define NUMSUBKEYS 52
#define NUMROUNDS 8
#define MAXINPUTSIZE 32
// I had problems if we use #define with
// these nums. Problem arose when taking
// mod of this number
unsigned int TWOPOWER16 = 65536;
unsigned int TWOPOWER161 = 65537;
unsigned int inputsize;
// all the subkey information
unsigned short esubkeys[NUMSUBKEYS];
unsigned short dsubkeys[NUMSUBKEYS];
unsigned int origkeyint[4];
unsigned char origkeychar[17];
//****************************************
// argument is an array of chars and prints
// the hex value of 4 consecutive chars (4 bytes)
// starting at the pointer. It loops until
// all the bits in the original string are read
//****************************************
void printHex (unsigned char* start)
{
unsigned int* val = (unsigned int*)start;
int times = inputsize/4;
cout <<endl;
for (int i=0; i<times;i++) {
printf ("\t\tbits %03d to %03d: 0x%08x\n",(32*i)+1,8*4*(i+1),*val);
start+=4;
val = (unsigned int*)start;
}
}
//****************************************
// This is the core encryption and decryption
// engine which does all the rounds and does
// all the arithmetic operations (add,mult,xor,swap,inverse)
//****************************************
void runIdea(unsigned char* msg, unsigned char* outmsg,unsigned short* keysbit16,int writeflag)
{
//if writeflag is 1, then we print round by round results
unsigned short x1,x2,x3,x4;
unsigned short y1,y2,y3,y4;
unsigned short x5,x6,x7,x8,x9,x10;
unsigned short x11,x12,x13,x14;
unsigned short xtemp;
unsigned int writeint;
// msg is 1 byte. make 2 byte ptr to facilitate ing for
// 16 bit fields
// 2 bytes go into x1, 2 bytes go into x2,etc
unsigned short* msgbit16 = (unsigned short*) msg;
//cout << "msg is " << *msg <<endl;
x1 = *msgbit16++;
x2 = *msgbit16++;
x3 = *msgbit16++;
x4 = *msgbit16++;
//x1 = (x1 >>8) | (x1<<8);
//x2 = (x2 >>8) | (x2<<8);
//x3 = (x3 >>8) | (x3<<8);
//x4 = (x4 >>8) | (x4<<8);
// this is for debug purposes. make greater than 8
// if don't want debugs
int tst=9;
// note that mod 2^16+1 could yield a value which is 2^16.
// this is greater than space for 16 bits, so i think
// the mod operation makes 2^16 mod 2^16+1 equal to 0.
for (int i=0; i<NUMROUNDS;i++)
{
//IY
if (i==tst )
cout << "STEP 1: x1 is " << x1 << ", key is " << *keysbit16 << endl;
//STEP 1 of 14
x1 = (x1* (*keysbit16++)) % TWOPOWER161;
//IY
if (i==tst )
cout << "\tAfter mul, x1 is " << x1 << endl;
//IY
if (i==tst )
cout << "STEP 2: x2 is " << x2 << ", key is " << *keysbit16 << endl;
//STEP 2 of 14
x2 = (x2 + *keysbit16++) % TWOPOWER16;
//IY
if (i==tst )
cout << "\tAfter add, x2 is " << x2 << endl;
//IY
if (i==tst )
cout << "STEP 3: x3 is " << x3 << ", key is " << *keysbit16 << endl;
//STEP 3 of 14
x3 = (x3 + *keysbit16++) % TWOPOWER16;
//IY
if (i==tst )
cout << "\tAfter add, x3 is " << x3 << endl;
//IY
if (i==tst )
cout << "STEP 4: x4 is " << x4 << ", key is " << *keysbit16 << endl;
//STEP 4 of 14
x4 = (x4* (*keysbit16++)) % TWOPOWER161;
//IY
if (i==tst )
cout << "\tAfter mul, x4 is " << x4 << endl;
//IY
if (i==tst)
cout << "STEP 5: x3 is " << x3 << ", x1 is " << x1 << endl;
//STEP 5 of 14
x5 = x1^x3;
if (i==tst)
cout << "\tAfter XOR, x5 is " << x5 << endl;
//IY
if (i==tst)
cout << "STEP 6(outorder): x2 is " << x2 << ", x4 is " << x4 << endl;
//STEP 6 of 14
x6 = x2^x4;
//IY
if (i==tst)
cout << "\tAfter XOR, x6 is " << x6 << endl;
//IY
if (i==tst)
cout << "STEP 7(outorder): x5 is " << x5 << ", key is " << *keysbit16 << endl;
//STEP 7 of 14
x7 = (x5* (*keysbit16++)) % TWOPOWER161;
if (i==tst)
cout << "\tAfter mul, x7 is " << x7 << endl;
//IY
if (i==tst)
cout << "STEP 8: x6 is " << x6 << ", x7 is " << x7 << endl;
//STEP 8 of 14
x8 = (x6+x7) % TWOPOWER16;
//IY
if (i==tst)
cout << "\tAfter ADD, x8 is " << x8 << endl;
//IY
if (i==tst)
cout << "STEP 9: x8 is " << x8 << ", key is " << *keysbit16 << endl;
//STEP 9 of 14
x9 = (x8* (*keysbit16++)) % TWOPOWER161;
//IY
if (i==tst)
cout << "\tAfter mul, x9 is " << x9 << endl;
//IY
if (i==tst)
cout << "STEP 10: x7 is " << x7 << ", x9 is " << x9 << endl;
//STEP 10 of 14
x10 = (x7+x9) % TWOPOWER16;
//IY
if (i==tst)
cout << "\tAfter add, x10 is " << x10 << endl;
//STEP 11,12,13,14 of 14
x11=x1^x9;
x12=x3^x9;
x13=x2^x10;
x14=x4^x10;
if (i==tst ) {
cout << "\tSTEP11: After XOR, x11 is " << x11 << endl;
cout << "\tSTEP12: After XOR, x12(after swap) is " << x12 << endl;
cout << "\tStep13: After XOR, x13(after swap) is " << x13 << endl;
cout << "\tStep14: After XOR, x14 is " << x14 << endl;
}
//new values for next iteration
x1=x11;
x2=x12;
x3=x13;
x4=x14;
if (writeflag==1) {
printf ("ROUND %d:\n", i+1);
writeint = (x1<<16) + x2;
printf("\tBits 1 to 32 0x%08x\n",writeint);
writeint = (x3<<16) + x4;
printf("\tBits 33 to 64 0x%08x\n\n",writeint);
}
} // foreach round
//final output transformation. modify 4 subkeys like so:
y1 = (x11 * (*keysbit16++)) % TWOPOWER161;
//flip flop these two!
y3 = (x13 + *keysbit16++) % TWOPOWER16;
y2 = (x12 + *keysbit16++) %TWOPOWER16;
y4 = (x14 * (*keysbit16)) % TWOPOWER161;
// put new data into the buffer
msgbit16=(unsigned short*)outmsg;
*msgbit16++ = y1;
*msgbit16++ = y3;
*msgbit16++ = y2;
*msgbit16 = y4;
//*msgbit16++ = (y1 >>8) | (y1<<8);
//*msgbit16++ = (y3 >>8) | (y3<<8);
//*msgbit16++ = (y2 >>8) | (y2<<8);
//*msgbit16 = (y4 >>8) | (y4<<8);
if (writeflag==1) {
unsigned int tempint;
printf ("AFTER OUTPUT TRANSFORMATION AND SWAP:\n");
msgbit16=(unsigned short*)outmsg;
tempint = (y1 <<16) + y3;
printf ("\tBits 1 to 32 0x%08x\n",tempint);
tempint = (y2 <<16) + y4;
printf ("\tBits 33 to 64 0x%08x\n",tempint);
}
} // end runIdea
//****************************************
// each block is 8 bytes (64 bits), so
// we loop until all blocks have been encrypted
// essentially hands over work to runIdea
//****************************************
void encrypt (unsigned char* msg,unsigned char* outmsg,int writeflag)
{
int blocks = inputsize/8;
unsigned char* inptr=msg;
unsigned char* outptr=outmsg;
for(int i=0;i<blocks;i++) {
if (writeflag==1) {
printf ("Results for Data Block %d\n", i+1);
printf ("=======================\n\n");
}
runIdea(inptr,outptr,esubkeys,writeflag);
inptr+=8;
outptr+=8;
}
}
//****************************************
// each block is 8 bytes (64 bits), so
// we loop until all blocks have been decrypted
// essentially hands over work to runIdea
//****************************************
void decrypt (unsigned char* msg,unsigned char* outmsg,int writeflag)
{
int blocks = inputsize/8;
unsigned char* inptr=msg;
unsigned char* outptr=outmsg;
for(int i=0;i<blocks;i++) {
if (writeflag==1) {
printf ("Results for Data Block %d\n", i+1);
printf ("=======================\n\n");
}
runIdea(inptr,outptr,dsubkeys,writeflag);
inptr+=8;
outptr+=8;
}
} //end of decrypt
//****************************************
// Finds the inverse of a 16 bit number mod 2^16+1
// uses extended euclidean algorithm
//****************************************
//unsigned short inv(unsigned short b)
short inv(unsigned short b)
{
// what book said to do if taking mod of 0 or 1
if (b==0 || b==1)
return b;
// initial variables
int a = 65536+1; // 2^16 + 1
int g0 = a;
int g1 = b;
int v0 = 0;
int v1 = 1;
int savev0;
int q;
int rem;
int numloops = 0;
// start of extended euglidean algorithm
while (g1 != 0) {
numloops++;
q = g0/g1;
rem = g0 % g1;
g0=g1;
g1 = rem;
savev0=v0;
v0 = v1;
v1 = savev0 - (v1*q);
}
assert (g0==1);
//IMPORTANT - since we're dealing wih signs, if we end up with a negative
// number, for some reason the positive equivalent was off by 1. so add
// 1 to value if negative result was found. Not sure why.
if (v0 >1)
return v0;
else
return 1+v0;
} // end inv
//****************************************
// Prints the original 128 bit key in hex
//****************************************
void printOrigKey()
{
printf ("Original Key in text: %s\n",origkeychar);
printf ("\tOriginal Key 1st 32bits: 0x%08x\n",origkeyint[0]);
printf ("\tOriginal Key 2nd 32bits: 0x%08x\n",origkeyint[1]);
printf ("\tOriginal Key 3rd 32bits: 0x%08x\n",origkeyint[2]);
printf ("\tOriginal Key 4th 32bits: 0x%08x\n",origkeyint[3]);
}
//****************************************
// Prints out the 52 subkeys used for encryption
// and decryption
//****************************************
void printKeys()
{
int count=1;
cout << "\n\n***** ENCRYPTION AND DECRYPTION SUBKEY SUMMARY *****" <<endl;
cout << endl << "All Subkeys are 16 bits." <<endl<<endl;
printOrigKey();
for (int k=0; k<NUMSUBKEYS;k++) {
if (k%6 ==0) {
cout <<"\nEncryption Subkeys Round " << count ;
cout <<" Decryption Subkeys Round " << count << endl;
count++;
}
printf (" subkey %02d 0x%08x",k,esubkeys[k]);
printf (" subkey %02d 0x%08x\n",k,dsubkeys[k]);
}
}//end printKeys
//****************************************
// based on the 52 encryption subkeys, find
// tje 52 decryption subkeys (16 bit)
//****************************************
void calcDKeys ()
{
//*** 1st,4th subkey for each round
for (int i=0;i<NUMSUBKEYS;i+=6) {
dsubkeys[i] = inv(esubkeys[48-i]);
dsubkeys[i+3] = inv(esubkeys[48-i+3]);
}
//*** 2nd, 3rd subkey for each round
dsubkeys[1] = -1 * esubkeys[49]; //first round
dsubkeys[2] = -1 * esubkeys[50]; //first round
for (int i =7; i<NUMSUBKEYS;i+=6) {
dsubkeys[i] = -1 * esubkeys[51-i];
dsubkeys[i+1] = -1 * esubkeys[50-i];
}
dsubkeys[49] = -1 * esubkeys[1]; //last round
dsubkeys[50] = -1 * esubkeys[2]; //last round
//*** 5th, 6th subkey for each round
for (int i=4; i< (NUMSUBKEYS) ; i+=6) {
dsubkeys[i] = esubkeys[50-i];
dsubkeys[i+1] = esubkeys[51-i];
}
int count=1;
for (int k=0; k<NUMSUBKEYS;k++) {
if (k%6 ==0) {
//IY cout <<"\nDSUBKEYS FOR ROUND " << count << endl;
count++;
}
//IY cout <<"subkey " << k << " = " << dsubkeys[k]<<endl;
}
} //end calcDKeys
//****************************************
// Takes original 128 bit key which is
// passed in as array of bytes and
// calculate encryption subkeys (52 total - 16 bits)
//****************************************
void calcEKeys(unsigned char* userkey)
{
//keys from example
//char userkey[16];
//for(int i=0; i<16; i++)
//userkey[i] = i+1;
int firstbyte = 0;
//merge two 8-bit sections into one 16 bit!!!
// this is done by bitwise shifting. most of logic in this
// funciton is because of this
for (int j=0; j<8;j++) {
esubkeys[j] = (userkey[firstbyte] <<8) + userkey[firstbyte+1];
firstbyte = firstbyte+2;
}
for (int f=8; f<NUMSUBKEYS-4;f+=8) {
//shift 25 bits.
//if we're on subkey 1, then get last 7 bits of subkey 2, and
//first 9 bits of subkey 2
// first 6 subkeys
for (int n=0;n<6;n++) {
esubkeys[f+n] = (short) ((esubkeys[f+n-7] <<9) | (esubkeys[f+n-6] >>7));
}
// next 2 esubkeys
esubkeys[f+6] = (short) ((esubkeys[f+6-7] <<9) | (esubkeys[f+6-6-8]>>7));
esubkeys[f+7] = (short) ((esubkeys[f+7-7-8] <<9) | (esubkeys[f+7-6-8]>>7));
}
// subkeys 48-51
esubkeys[NUMSUBKEYS-4] = (short) ((esubkeys[NUMSUBKEYS-4-7] <<9) | (esubkeys[NUMSUBKEYS-4-6] >>7));
esubkeys[NUMSUBKEYS-4+1] = (short) ((esubkeys[NUMSUBKEYS-4+1-7] <<9) | (esubkeys[NUMSUBKEYS-4+1-6] >>7));
esubkeys[NUMSUBKEYS-4+2] = (short) ((esubkeys[NUMSUBKEYS-4+2-7] <<9) | (esubkeys[NUMSUBKEYS-4+2-6] >>7));
esubkeys[NUMSUBKEYS-4+3] = (short) ((esubkeys[NUMSUBKEYS-4+3-7] <<9) | (esubkeys[NUMSUBKEYS-4+3-6] >>7));
int count=1;
for (int k=0; k<NUMSUBKEYS;k++) {
if (k%6 ==0) {
//cout <<"\nSUBKEYS FOR ROUND " << count << endl;
count++;
}
//cout <<"subkey " << k<< " = " << esubkeys[k]<<endl;
}
} //end calcEKeys
//****************************************
// states that program has started.
//****************************************
void promptWelcome()
{
if (sizeof(unsigned short)!=2){
cout <<" size of unsigned short is not 2 bytes. Please run on flop.engr.orst.e or on another machine. This program needs 2 bytes for unsigned short to simulate the 16-bit subkeys" <<endl;
exit(0);
}
cout << endl <<endl;
cout << "************ WELCOME ***************" <<endl;
cout << "This is Irwin Yoon's program illustrating " <<endl;
cout << "IDEA (International Data Encryption Algorithm)" <<endl;
cout << "************************************" <<endl;
cout << endl <<endl;
} //end promptWelcome
//****************************************
// prompt the user to enter either plaintext
// or ciphertext. puts value in array
// that is passed in
//****************************************
void promptForText(unsigned char* ptext,int encryptionflag)
{
std::string str;
if (encryptionflag ==1)
cout << endl << "************ ENCRYPTION OF PLAINTEXT **********" <<endl<<endl;
else
cout << endl << "************ DECRYPTION OF CIPHERTEXT **********" <<endl<<endl;
while (1) {
cout << "Data block size is 8 bits. " <<endl;
cout << "Therefore, please enter 8, 16, 24, 32 characters" <<endl;
if (encryptionflag ==1)
cout << "Your Plaintext input: ";
else
cout << "Your Ciphertext input: ";
getline(cin, str);
if ((str.size() == 8) || (str.size()==16) || (str.size()==24) || (str.size()==32))
break;
else
cout <<endl<< "ERROR: input was " << str.size()<< " instead of 8,16,24,32 chars. Try Again" <<endl <<endl;
}
inputsize = str.size();
for (int i=0;i<str.size();i++) {
ptext[i] = str[i];
}
ptext[inputsize]='\0';
} //prompt for plaintext
//****************************************
// We have to prompt user to enter 128 bit
// key. since we only have 1 byte chars
// make the user enter 16 characters, which
// we convert to 128 bit key
//****************************************
void promptForKey()
{
cout << "IDEA takes in a 128-bit key. " <<endl;
cout << "User will enter 16 alphanumeric characters" <<endl;
cout << "These 16 alphanumeric characters will be "<< endl;
cout << "converted to a 128-bit key. " <<endl;
cout << " (16 char * 8bits = 128 bits)" <<endl;
cout << endl <<endl;
std::string str;
while (1) {
cout << "Please enter 16 alphanumberic characters, then press enter" <<endl;
getline(cin, str);
if (str.size() == 16)
break;
else
cout <<endl<< "ERROR: That was not 16 alphanumeric chars. Try Again" <<endl <<endl;
}
for (int i=0;i<16;i++) {
origkeychar[i] = str[i];
}
origkeychar[16]='\0';
cout << endl << "Thank you."<<endl ;
//translate to hex
int firstbyte = 0;
for (int j=0; j<4;j++) {
//merge two 8-bit sections into one 16 bit
origkeyint[j] = (origkeychar[firstbyte] <<24) + (origkeychar[firstbyte+1]<<16)
+ (origkeychar[firstbyte+2]<<8) + (origkeychar[firstbyte+3]);
firstbyte = firstbyte+4;
}
printOrigKey();
} //end promptForKey
//****************************************
// prints hex and ascii of plaintext
//****************************************
void printPlainTextSummary(unsigned char* plaintext)
{
plaintext[inputsize]='\0';
printf ("\n\nYour Plaintext\n");
printf ("=================================\n");
printf ("Plaintext in ASCII: \"%s\"\n",plaintext);
printf ("Plaintext in Hex:");
printHex(plaintext);
}
//****************************************
// prints hex of ciphertext
//****************************************
void printCipherTextSummary(unsigned char* ciphertext)
{
ciphertext[inputsize] = '\0';
printf ("\n\nThe Resulting Ciphertext\n");
printf ("=================================\n");
printf ("Ciphertext in Hex:");
printHex(ciphertext);
}
//****************************************
// prints hex and ascii of decrypted
// ciphertext
//****************************************
void printDecipherTextSummary(unsigned char* decipheredtext)
{
decipheredtext[inputsize] = '\0';
printf ("\n\nDecrypt the Ciphertext\n");
printf ("=================================\n");
printf ("Decrypted text in ASCII: \"%s\"\n",decipheredtext);
printf ("Decrypted text in Hex:");
printHex(decipheredtext);
}
//****************************************
// THE MAIN LOOP! CONTINUALLY prompts
// user for input and processes request
//****************************************
int main()
{
promptWelcome();
promptForKey();
//NOTE: override user prompted key only for testing purposes
//unsigned char origkeychar[17];
//for(int i=0; i<16; i++)
//origkeychar[i] = i+1;
//origkeychar[16]='\0';
calcEKeys(origkeychar);
calcDKeys();
std::string str;
unsigned char ciphertext[MAXINPUTSIZE+1];
unsigned char decipheredtext[MAXINPUTSIZE+1];
unsigned char plaintext[MAXINPUTSIZE+1];
ciphertext[MAXINPUTSIZE] = '\0';
decipheredtext[MAXINPUTSIZE] = '\0';
unsigned int myint;
unsigned int* intptr;
//*********************
//******** MAIN LOOP
//*********************
while (1) {
cout << endl <<endl << "MAIN MENU" <<endl;
cout << "=========" <<endl;
cout << "Press 1 to print all Encryption/decryption keys " <<endl;
cout << "Press 2 to encrypt plaintext with intermediate results" <<endl;
cout << "Press 3 to decipher ciphertext with intermediate results" <<endl;
cout << "Press 4 to encrypt, then decrypt "
<< "(No intermediate results shown)" <<endl;
cout << "Press 5 to quit " <<endl<<endl;
cout << "Your choice: " ;
getline(cin, str);
// I should probably use switch statements instead, but it's
// too late
if (str[0] == '1')
printKeys();
else if (str[0]=='2') {
promptForText(plaintext,1);
encrypt(plaintext,ciphertext,1);
printCipherTextSummary(ciphertext);
}
else if (str[0]=='3') {
promptForText(ciphertext,0);
decrypt(ciphertext,decipheredtext,1);
printDecipherTextSummary(decipheredtext);
}
else if(str[0]=='4') {
promptForText(plaintext,1);
encrypt(plaintext,ciphertext,0);
decrypt(ciphertext,decipheredtext,0);
printPlainTextSummary(plaintext);
printCipherTextSummary(ciphertext);
printDecipherTextSummary(decipheredtext);
}
else if(str[0]=='5') {
cout << "****** Exiting IDEA program. Good bye. " <<endl<<endl;
exit(0);
}
else {
cout <<"Error: Invalid input" <<endl;
}
} // end main loop
return 0;
} //end main
⑧ android開發一般都使用什麼框架
目前框架使用的主要都是開源框架，都可以在github上找到：
1、volley
2、android-async-http
3、Afinal框架
4、xUtils框架
5、ThinkAndroid
6、LoonAndroid
主要有以下模塊：
(1) 自動注入框架（只需要繼承框架內的application既可）
(2)
圖片載入框架（多重緩存，自動回收，最大限度保證內存的安全性）
(3) 網路請求模塊（繼承了基本上現在所有的http請求）
(4)
eventbus（集成一個開源的框架）
(5) 驗證框架（集成開源框架）
(6) json解析（支持解析成集合或者對象）
(7) 資料庫（不知道是哪位寫的 忘記了）
(8) 多線程斷點下載（自動判斷是否支持多線程，判斷是否是重定向）
(9)
自動更新模塊
(10) 一系列工具類
⑨ 結合Android看看單例模式怎麼寫
單例模式常見的兩種實現方式 餓漢模式和 雙重鎖模式
•餓漢模式
public class HungrySingleton {
private static HungrySingleton mInstance = new HungrySingleton();
private HungrySingleton() {
}
public static HungrySingleton getInstance() {
return mInstance;
}
}
不得不說，餓漢模式這個名字起得的確很巧，這種方式，不管你用不用得著這個實例，先給你創建（new）出來，生怕將來創建沒機會似得，完全就是今朝有酒今朝醉的節奏。
與上面對應的還有一種就是懶漢模式，就是在用的時候才在getInstance 方法中完成實例的創建（new），真是「懶」，同時給這個方法添加synchronized 關鍵字，可以確保在多線程情況下單例依舊唯一，但是懶漢模式每次調用getInstance 方法時由於synchronized 的存在，需要進行同步，造成不必要的資源開銷。因此便有了下面雙重鎖模式的實現方式。
•雙重鎖模式（DCL 實現）
public class LazySingleton {
private static LazySingleton mInstance = null;
private LazySingleton() {
}
public static LazySingleton getInstance() {
if (mInstance == null) {
synchronized (LazySingleton.class) {
if (mInstance == null) {
mInstance = new LazySingleton();
}
}
}
return mInstance;
}
}
這樣既避免了餓漢模式的缺點，又解決了懶漢模式的不足；確保單例只在第一次真正需要的時候創建。
Android 中的使用
在日常的Android開發中，也可以見到單例模式的身影。
•Glide
使用Glide載入圖片非常方便，大家應該不陌生，可以看一下它的源碼中單例模式的實現方式。
Glide.with(this).load(url).into(imageView);
//Glide.with()
public static RequestManager with(FragmentActivity activity) {
RequestManagerRetriever retriever = RequestManagerRetriever.get();
return retriever.get(activity);
}
//RequestManagerRetriever.get()
/** The singleton instance of RequestManagerRetriever. */
private static final RequestManagerRetriever INSTANCE = new RequestManagerRetriever();
/**
* Retrieves and returns the RequestManagerRetriever singleton.
*/
public static RequestManagerRetriever get() {
return INSTANCE;
}
可以看到，當我們寫下Glide.with(..) 這行代碼時，就完成了RequestManagerRetriever 這個類的實例化，這個類的單例模式是使用餓漢模式實現的。
•EventBus
public static EventBus getDefault() {
if (defaultInstance == null) {
synchronized (EventBus.class) {
if (defaultInstance == null) {
defaultInstance = new EventBus();
}
}
}
return defaultInstance;
};
很明顯，EventBus的單例模式使用雙重鎖模式實現的。
•InputMethodManager static InputMethodManager sInstance
public static InputMethodManager getInstance() {
synchronized (InputMethodManager.class) {
if (sInstance == null) {
IBinder b = ServiceManager.getService(Context.INPUT_METHOD_SERVICE);
IInputMethodManager service = IInputMethodManager.Stub.asInterface(b);
sInstance = new InputMethodManager(service, Looper.getMainLooper());
}
return sInstance;
}
}
InputMethodManager 的單例模式是使用懶漢模式實現。
可以看到，關於單例模式的實現方式，面對不同的場景，我們可以做出不同的選擇
•Glide的單例模式雖然是使用餓漢模式實現，但理論上來說並不會造成內存資源的浪費，因為當我們通過gradle的配置引入Glide的庫時，就是為了載入圖片，必然會使用Glide.with進行相關的操作。同時RequestManagerRetriever 這個類應該是一個網路請求的管理類（Glide源碼沒有研究過，這里只是猜測），這樣的一個類必然需要使用單列模式，試想如果存在多個管理類的實例，那麼談何管理，那麼的多Request到底聽哪個manger 的，這就是前面提到必須使用單列模式的情景。
•EventBus 作為事件匯流排的更要使用單例模式了，如果說EventBus的實例不是單例模式，那麼他就無法實現它的功能了。對於EventBus不了解的同學，可以看看
EventBus 3.0 相見恨晚，EventBus真的很強大。
•InputMethodManager 使用懶漢模式實現單例也是無可厚非的，畢竟誰會去頻繁的獲取那麼多他的實例呢；同時作為一個系統的輸入法管理器，他也必須是唯一的，因此這個類也需要單例模式來實現它唯一的實例供外部使用。
由上可見，關於單例模式的實現，沒有說哪一種方式最好，只有最合適的實現方式；實際開發中，單例模式應該怎麼寫，還需要根據業務場景做最合適的選擇，無論是餓漢懶漢實用才是好漢。個人感覺，餓漢模式是一種簡單又方便的實現方式， 一個類既然已經寫成了單例模式，必然是要使用的呀，誰會去創建一個餓漢模式的單例，又不去使用這個單例呢？
之前在使用Volley的時候，就是使用餓漢模式創建整個應用的RequestQueue單例，所有需要網路請求的地方，把request添加到RequestQueue單例中即可。
public class MyApplication extends Application{
// 建立請求隊列
public static RequestQueue queue;
@Override
public void onCreate() {
super.onCreate();
queue = Volley.newRequestQueue(getApplicationContext());
}
public static RequestQueue getHttpQueue() {
return queue;
}
}
在應用Application的onCreate方法中創建了屬於整個應用的queue，之後每一次網路請求時，只需要queue.add(Request)即可，這里使用單例模式，可以有效的避免在多個地方創建RequestQueue 的實例，浪費系統資源。
⑩ 怎麼查看網頁打開時調用了哪些js
想看網頁調用了哪些js的話你就在你想看的頁面，右鍵——查看網頁源代碼，然後你會看到一堆字母，在裡面找用「大於號，小於號」括起來的，中間寫著script字樣的成對的，這個叫標簽，中間的都是這個頁面載入的js。