怎麼在容器里編程

Ⅰ c++ stl里的向量vector非常好用，那麼它是怎麼實現的呢

這個要去翻源碼了，STL里的代碼說實話，真的看不太懂。

如果不是太糾結於具體細節，可以簡單講講基本的實現思路，大致如下：

1. vector從功能上來講，屬於順序存儲容器，所以底層實現一般基於數組。

2. vector使用模板元編程技術實現，具體一點就是編譯器根據使用時指定的實際類型在編譯時執行模板特化，編譯出對應的代碼。也就是說vector<int> v1; vector<double>v2;它們各對應一個特化版本的代碼。這提高了代碼的抽象級別，但是對帶來了代碼膨脹的問題。

3. vector的重要特性之一就是實現了數組的動態遞增。簡單來說就是容器內部記錄當前的足最大容量和使用量。當添加元素的時候，如果容器類發現當前的容量已耗盡，容器類會自動地重新分配一個更大容量的數組，把當前的所有元素過去，然後釋放掉舊的數組，從而實現動態自增，這一切對使用者來說完全透明。

4. vector提供迭代器來提供統一的遍歷訪問介面，方便與STL中的其它組件進行交互。

   
   

   
   

這其中會有很多的細節，比如：

1. 是否允許vector在必要時縮小自身容量？

2. vector容量耗盡後的遞增量是多少？

3. 是否應該提供線程安全容器？

有些東西可能真的需要去翻源碼去看才能搞明白。或者可以參考侯捷的《STL源碼剖析》。其實vector本身的實現並不會太復雜，它的實現思路也很簡單，但是設計層面的一些取捨就需要經過仔細考量了。一般來說，STL是一個足夠堅實的後盾，我們會頻繁地使用它，以構建健壯高效的軟體。能夠理解STL里的一些設計思想和實現方式，對提高我們的編程思維和編程能力會所幫助。

Ⅱ 編寫程序界面中包括一個標簽、一個文本框和一個按鈕。當用戶單擊按鈕時，程序把文本框的內容復制到標簽中

1、首先打開電腦的java編寫工具，然後創建一個java項目，文件為Demo2。

Ⅲ 1、編程解決如下數學問題：有12升水，怎樣利用一個8升和一個5升的容器將水分為兩個6升列印出分水步驟。

#include"stdio.h"

void Move(int *a,int *b,int aMax,int bMax)
{
if(aMax>bMax)
{
if((*a+*b)>bMax)

{ *a=*a-(bMax-*b);
*b=*b+bMax-*b;
}
else
{
*b=*a+*b;
*a=*a-*a;
}
}
else
{
*b=*b+*a;
*a=0;
}

}
int check(int aMax,int bMax,int cMax)
{

if(aMax>bMax&bMax>cMax)
return 0;
else
return 1;
}
int main()
{
int a;
int b;
int c;
int aMax,bMax,cMax;
//aMax=40;bMax=14;cMax=8;
label3:
printf("待分配水量杯A：");
scanf("%d",&aMax);
printf("量杯B容量:");
scanf("%d",&bMax);
printf("量杯C容量:");
scanf("%d",&cMax);
if(check(aMax,bMax,cMax))
{
printf("容量輸入有誤！請重新輸入.\n");
goto label3;
}
a=aMax;
b=0;
c=0;
int m=0;

while(m<100){

Move(&a,&b,aMax,bMax);
printf("A->B:%d %d %d\n",a,b,c);
m++;
if(b==aMax/2&a==aMax/2) goto label2;
Move(&b,&c,bMax,cMax);
printf("B->C:%d %d %d\n",a,b,c);
m++;
if(b==aMax/2&a==aMax/2) goto label2;
label1:
Move(&c,&a,cMax,aMax);
printf("C->A:%d %d %d\n",a,b,c);
m++;
if(b==aMax/2&a==aMax/2) goto label2;

Move(&b,&c,bMax,cMax);
printf("B->C:%d %d %d\n",a,b,c);
m++;
if(b==aMax/2&a==aMax/2) goto label2;
if(c==cMax) goto label1;

}
label2:

printf("共需%d步\n",m);

printf("%d %d %d\n",a,b,c);

return 0;
}

Ⅳ spring中的aop 是怎麼面向切面編程的

Spring面向切面編程(AOP)

1 spring容器中bean特性

Spring容器的javabean對象默認是單例的。

通過在xml文件中，配置可以使用某些對象為多列。

Spring容器中的javabean對象默認是立即載入（立即實例化：spring載入完成，立即創建對象）

scope:屬性

singleton：默認值為單例，默認也是立即載入,在載入完成spring容器的時候，bean對象已經創建完成

prototype：多例的，默認懶載入，spring容器載入完成的時候，不會創建bean的對象，只有從容器獲得bean對象的時候，才進行bean對象的實例化

request: 將創建的javabean對象，封裝到request范圍

session:將創建的javabean對象，封裝到session范圍

Spring容器bean的對象生命周期：

Bean對象的創建一直到銷毀為bean的生命周期。

生命周期的開始：

如果為單例，由載入完spring容器開始

如果為多例，由從容器獲得bean對象開始

實例化

初始化

服務

銷毀(單例：關閉容器的時候，多例由jvm自動回收)

2 spring的AOP面向切面編程

2.1 模擬銀行轉賬業務

需求：實現銀行的轉賬功能，在轉賬的時候需要完成

1 身份認證（登陸）

2 許可權的驗證

3 轉賬實現

4 歷史交易記錄，

分析：1，2，4三個功能對於銀行的業務，屬於公共的功能（共性的功能）

在功能實現的時候，需要將1，2，4抽取出來，單獨實現，

做到了將共性的功能和核心的業務功能進行了分離

通過動態代理實現：共性的功能和核心業務功能的合並，產生核心業務對象的

在代碼實現的時候，進行了功能實現的分離：

代碼開發的進行分離，程序在運行的時候進行合並。

2.2 springAOP的思想

在系統開發中，將系統的共性的公共的功能獨立實現，在程序運行的過程中，將共性功能和核心的業務功能，進行整合。

好處：

1 完成共性功能和核心業務功能的解耦合

2 提供共性功能的復用性。

2.3springAOP的概念

Aspect切面：封裝共性功能的（增強功能的）類

Advice通過：切面類中封裝的增強功能的方法。

PointCut:切入點，是一個集合的概念，該集合的表達使用一個正則表達式表達

所有核心業務對象的所有方法的前後（事務處理AOP典型的應用）

JoinPoint:連接點，程序中需要加入advice的地方，而且正在執行的ponitCut

織入(Weaving)：將aspect和核心業務對象，進行整合的過程。

3 springAOP的實現

3.1通過特定介面實現

Aop通知的類型：

Before:前置通知

After：後置通知

Around：環繞通知

Throwing：異常通知

需求：實現在業務對象中的方法執行的時候，記錄日誌功能

3.1.1前置通知

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Arrays;
importjava.util.Date;
importorg.springframework.aop.MethodBeforeAdvice;
/****
*前置增強：
*MethodBeforeAdvice介面表示重寫的方法為前置advice
****/

{
@Override
publicvoidbefore(Methodmethod,
Object[]args,Objectobj)
throwsThrowable
{
System.out.println(method);
System.out.println(Arrays.toString(args));
System.out.println(obj);
System.out.println("BeforeLog-------------"+newDate());
}
}

AOP配置:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--到入xml文件的約束-->
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--實例化BeforeLog對象-->
<beanid="bf"class="org.guangsoft.utils.BeforeLog"></bean>
<!--實例化service對象-->
<beanid="us"class="org.guangsoft.service.impl.UsersServiceImpl"/>
<!--進行aop的配置，產生代理對象-->
<aop:config>
<!--聲明切入點-->
<aop:pointcutexpression="execution(*org.guansoft.service.impl.*.*(..))"
id="pc"/>
<!--織入將通知和切入點進行合並（切面+核心業務對象）-->
<aop:advisoradvice-ref="bf"pointcut-ref="pc"/>
</aop:config>
</beans>

3.1.2後置通知

對業務對象的方法進行後增強。

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Date;
importorg.springframework.aop.AfterReturningAdvice;
/***
*後置通知
****/

{
@Override
publicvoidafterReturning(Objectobj1,//obj1接收目標方法的返回值
Methodmethod,
Object[]args,
Objectobj2)throwsThrowable
{
//System.out.println(obj1+"----------------------"+obj2);
System.out.println("AfterLog-------------------"+newDate());
}
}

AOP配置:

<?xmlversion="1.0"encoding="UTF-8"?>
<!--到入xml文件的約束-->
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:aop="http://www.springframework.org/schema/aop"xmlns:p="http://www.springframework.org/schema/p"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-4.1.xsd
http://www.springframework.org/schema/aop
http://www.springframework.org/schema/aop/spring-aop-4.1.xsd">
<!--實例化BeforeLog對象-->
<beanid="bf"class="org.guangsoft.utils.BeforeLog"></bean>
<beanid="af"class="org.guangsoft.utils.AfterLog"></bean>
<!--實例化service對象-->
<beanid="us"class="org.guangsoft.service.impl.UsersServiceImpl"/>
<!--進行aop的配置，產生代理對象-->
<aop:config>
<!--聲明切入點-->
<aop:pointcutexpression="execution(*org.guangsoft.service.impl.*.*(..))"
id="pc"/>
<!--織入將通知和切入點進行合並（切面+核心業務對象）-->
<aop:advisoradvice-ref="bf"pointcut-ref="pc"/>
<aop:advisoradvice-ref="af"pointcut-ref="pc"/>
</aop:config>
</beans>

3.1.3環繞通知

packageorg.guangsoft.utils;
importjava.lang.reflect.Method;
importjava.util.Arrays;
importjava.util.Date;
importorg.aopalliance.intercept.MethodInterceptor;
importorg.aopalliance.intercept.MethodInvocation;
/***
*環繞通知
****/

{
/**
*MethodInvocation中封裝了目標對象，調用的方法，方法需要的參數
****/
@Override
publicObjectinvoke(MethodInvocationmi)throwsThrowable
{
Methodmethod=mi.getMethod();
Object[]args=mi.getArguments();
Objectobj=mi.getThis();
System.out.println(method);
System.out.println(Arrays.toString(args));
System.out.println(obj);
System.out.println("around------before--------"+newDate());
Objectrv=method.invoke(obj,args);//調用目標對象的方法，放行
System.out.println("around------after--------"+newDate());
returnrv;
}
}

AOP配置：同上

3.1.4 異常通知

packageorg.guangsoft.utils;
importjava.util.Date;
importorg.springframework.aop.ThrowsAdvice;
/****
*異常通知
***/

{
/***
*該類中的方法參考AfterReturningAdvice寫
*該參數是用來接收異常信息的
****/
publicvoidafterThrowing(Throwableex)throwsThrowable
{
//System.out.println(obj1+"----------------------"+obj2);
System.out.println("ExceptionLog-----------"+ex.getMessage()
+"--------"+newDate());
}
}

Pointcut:核心業務對象

Advice：通知