כידוע בJAVA אובייקטים עוברים בסוג של BY POINTER(ולא BY REFF), כמו שרבים מרבים להטעות(או לטעות), איך שלא קוראים לזה, בכל מקרה זה לא BY REFF
מה שאני בעצם מנסה להגיד..

קוד:

swap(type_somthing 01,type_somthing 02){
	type_somthing tmp1=01;
	01=02;
	02=tmp;
}

type_somthing s1;
type_somthing s2;

swap(s1,s2);

ששום דבר מעניין אחרי הקריאה הזו לפונקציה SWAP, לא התרחש, והיא רצה על ריק..

האם יש דרך יעילה לכתוב פונקציה כזו? (לא כמו מפגר להשתמש בתוך SWAP פעמים בסוג של קופי-קונסטרקטור?)

לצורך העניין בCPP זה נעשה כך:

קוד:

void swap(int* &a,int* &b){
		int* tmp=a;
		a=b;
		b=tmp;
}

int a[]={1};
int b[]={2};

swap(a,b);

ואם כבר, איך ממשים קוד כזה בC(הרי ב C, אין רפרנס..)

טוב אחרי חיפוש קצר, מצאתי איזה דרך.. השאלה, האם קיים משהו יותר אלגנטי?

קוד:

public class Sim {

	/**
	 * @param args
	 */
	
	public static P[] swap(P p1,P p2){
		
		System.out.println("P1:"+p1.x+" P2:"+p2.x);//P[] tmp=new P[]{p2,p1};
		return new P[]{p2,p1};
	}
	
	
	public static void main(String[] args) {
	
		P p1=new P(1);
		P p2=new P(2);
		P[] p=swap(p1,p2);
		p1=p[0];
		p2=p[1];
		System.out.println("P1:"+p1.x+" P2:"+p2.x);
		

	}

}

ועד משהו נחמד באותו הנושא..

קוד:

template <class T> void swap ( T& a, T& b )
{
  T c(a); a=b; b=c;
}

ציטוט:

Notice how this function involves a copy construction and two assignment operations, which may not be the most efficient way of swapping the contents of classes that store large quantities of data, since each of these operations generally operate in linear time on their size. Because this function template is used as a primitive operation by many other algorithms, it is highly recommended that large data types overload their own specialization of this function. Notably, all STL containers define such specializations (at least for the standard allocator), in such a way that instead of swapping their entire data content, only the values of a few internal pointers are swapped, making this operation to operate in real constant time with them.

http://www.cplusplus.com/reference/algorithm/swap/

נראה לי שלימדו אותנו שבסי אפשר לעשות את ה SWAP עם XOR בין שני המשתנים (פונקציה של 3 שורות)
(אני מניח שזה תקף גם לשפות אחרות, פשוט אותנו לימדו את זה במהלך קורס C)
עריכה:
http://en.wikipedia.org/wiki/XOR_swap_algorithm

אני חושב שאני יודע למה אתה מתכוון..
אתה מתכוון לטריק המתמטי..
http://en.wikipedia.org/wiki/XOR_swap_algorithm

אבל זה לא ממש רלוונטי לנושא..

השאלה היא איך בC לשלוח שני סטרקטים כלשהם לפונקציה, וזו בתורה תעשה בניהם החלפה בo(1)
עולים לי כמה רעיונות בראש.. אבל אני מחכה לראות פתרונות של אנשים אחרים..

קוד:

#include <stdio.h>


void Swap(int** a,int **b){
	int* tmp=*a;
	*a=*b;
	*b=tmp;

}

int main(void) {

	int a[]={1,2,3};
	int b[]={4,5,6};

	printf("%d a %d b\n", a[0], b[0]);

	Swap(&a,&b);
	printf("%d a %d b\n", a[0], b[0]);

	return 0;
}

טוב, אפשר להבין מה פשר האזהרה שאני מקבל?

ציטוט:

passing argument 2 of 'Swap' from incompatible pointer type

ואם לא זו הדרך לעשות זאת בC, אז מה לעזזל כן?

הקומפיילר חושב שאתה שוכח משני האיברים האחרים במערך:
Warning 1 warning C4047: 'function' : 'int **' differs in levels of indirection from 'int (*)[3]'
אז או שתעשה casting ל-int** או שתתעלם מהאזהרה.

אגב, הפונקציה שלך מחליפה רק בין פוינטרים, אתה לא יכול להחליף בין שני structים למשל.

ציטוט:

במקור נכתב על ידי Michael Shermer Smart people are very good at rationalizing things they came to believe for non-smart reasons.

אני הצלחתי לעשות מה שרציתי..
כן, אני יודע שזה רק מחליף בין פויינטרים, זו הייתה המטרה.. התגובה הקודמת(ועוד כמה) זו אגב שטות גמורה.. (מה אני מנסה לעשות על המכסנית??)..
אני הולך לישון..

קוד:

#include <stdio.h>
#include <stdlib.h>

typedef struct{
	  double x;
	  double y;
	  double r;
}Circle;

void print_circle(Circle* c){
	printf("X:=%f Y:=%f R:=%f \n", c->x,c->y,c->r);
}


void swap(Circle** c1,Circle** c2){
	Circle* tmp=*c1;
	*c1=*c2;
	*c2=tmp;

}

int main(void) {


	Circle* c1;
	Circle* c2;

	c1=(Circle*)malloc(sizeof(Circle));
	c2=(Circle*)malloc(sizeof(Circle));

	c1->x=1; c2->x=55;
	c1->y=1; c2->y=55;
	c1->r=1; c2->r=55;

	swap(&c1,&c2);

	print_circle(c1);
	return 0;
}

Java אינה שפה השקולה ל-++C. המפתחים של Java כנראה ראו כי ההתעסקות ב-++C ו-C בפויינטרים ורפרנסים הינה מיותרת ולא באמת מוסיפה כח לשפת התכנות(אם אתה מתכנת נכון).

אם פונקציה כמו Swap ב-++C נחוצה לך בשביל ג'אווה, כנראה שעשית משהו לא נכון.
בכל אופן, אני יכול לחשוב על כמה דרכים(לא אלגנטיות כמו ב-++C) על לעשות Swap בין שני אובייקטים:

דרך ראשונה היא להגדיר טיפוס עוטף לטיפוס לו אתה רוצה לעשות Swap, ואת השדה היחידי של הטיפוס העוטף להגדיר מהטיפוס לו אתה רוצה לעשות Swap. ואז בפונקציה שאתה כותב תחליף בין שדות של שני טיפוסים עוטפים ולא בין הטיפוסים עצמם.

דרך שניה היא להגדיר פונקציית Swap כמתודה בטיפוס עצמו ולהעביר לה כפרמטר מצביע לאובייקט מאותו טיפוס, ומה שהמתודה תעשה זה תעתיק את תוכן(שדות) טיפוס א' לתוך טיפוס ב' וההפך.

זה לא עניין של

ציטוט:

נחוצה לך בשביל ג'אווה, כנראה שעשית משהו לא נכון.

א)אני יכול לחשוב על תרחשים בהם זה רצוי(עובדה אלה דברים שקיימים בCPP).
ב)אני לומד עכשיו c\c++ בגלל זה התעניינתי..

אם תתן דוגמא קונקרטית לתוכנית בה היית משתמש בפונקציה Swap, אז אפשר יהיה לחשוב איך היינו נמנעים מהפונקציה בתכנית ספציפית זו - סתם בשביל תרגיל מחשבתי.

בכל אופן זכור כי כנראה ש-++C ו-Java פותחו בתור שפות תכנות עם תכלית שונה ומכאן ההבדלים הללו.

הנה שימוש מעניין בסוואפ - החלפת איברים ברשימה מקושרת של סטראקטים.
השימוש בפוינטרים בסי נותן המון כוח.
זה שהאפשרות הזו לא קיימת בג'אווה נבע משיקולי אסטטיות ונגישות של השפה.
סי הרבה יותר "קרובה לברזלים" ועצם זה שאתה יכול לגשת לתא ספציפי בזיכרון זה לא דבר מובן מאליו.

נכון אתם אנשים כשרים, אך לא לזאת הייתה כוונתי. רציתי שתהיו כחיות הנוהמות ביער לילות שלמים.

ציטוט:

במקור נכתב על ידי Scattered mind אם תתן דוגמא קונקרטית לתוכנית בה היית משתמש בפונקציה Swap, אז אפשר יהיה לחשוב איך היינו נמנעים מהפונקציה בתכנית ספציפית זו - סתם בשביל תרגיל מחשבתי.

המון אלגוריתמי מיון?
עוד דוגמות: http://en.wikipedia.org/wiki/In-place_algorithm

פרמטרים עוברים בג'אווה by-value. אין דבר כזה "by-pointer". העניין הוא שג'אווה היא מהשפות המשעשעות שמתייחסות לטיפוסים פרימטיביים בצורה שונה מאשר לטיפוסים לא-פרימיטיביים. משתנים מטיפוסים פרימטיביים הם 'ערומים', בעוד משתנים מטיפוסים אחרים נגישים תמיד רק דרך reference אליהם.

הדבר אותו מעבירים לפונקציה תמיד עוברים by-value, אלא שכשמדובר במשתנים פרימטיביים, הערך שלהם מועתק למחסנית של הפונקציה, ואילו כשמדובר באובייקטים, ה-reference הוא שמועתק(!) למחסנית של הפונקציה.

ראה כאן:

• http://javadude.com/articles/passbyvalue.htm
• http://www.javaworld.com/javaworld/...-0526-pass.html
• http://stackoverflow.com/questions/...-method-in-java

(אלה כמובן דברים מהעמוד הראשון בגוגל...)

ציטוט:

במקור נכתב על ידי The_Equivocator האם יש דרך יעילה לכתוב פונקציה כזו? (לא כמו מפגר להשתמש בתוך SWAP פעמים בסוג של קופי-קונסטרקטור?)

יש דרך פשוטה מאוד לכתוב לכתוב מימוש יעיל של פנקציה כזו. כדי לעשות דבר כזה, אתה צריך לזכור באיזו שפה אתה מתכנת. בג'אווה, אתה יוצר ממשק בשם Swappable, שמכיל פונקציה בשם swap, שכל מי שמממש אותו יודע לממש swap יעיל לעצמו. משהו כזה: http://ideone.com/7AUE1

בעצם, זה די דומה לשיטה שבה ממשים swap יעיל ב-STL ב-CPP, כמו שכתוב בציטוט שהבאת בתגובה לעצמך...

וכן, מעכשיו אפשר להחליף רק אובייקטים שהם Swappable, כמו שאפשר להעתיק רק מה ש-Cloneable, לסדרת רק את מה שהוא Serializable, להריץ את מה ש-Runnable, ולחכות רק למה ש-Joinable.


עכשיו יש פה שתי בעיות:

1. מה אם אתה בכל-זאת רוצה להחליף טיפוסים שהם לא Swappable?
2. מה אם האובייקט ממש גדול, והדרך שבה מימשתי את swap לא יעילה?

ובכן, מסתבר שיש אותו פיתרון לשתי הבעיות האלה, והוא נקרא pimpl.
בגדול, זה אומר להחזיק משתנה פרטי שהוא "הדבר האמיתי", והאובייקט מבחוץ רק נותן גישה אליו. ב-CPP הסיבה לעשות את זה היא כדי לחסוך בקימפול מחדש, הריסת ממשקים, ועוד.
במקרה שלנו, זה מאפשר להפוך כל דרך שהוא לא-Swappable ל-Swappable.
הנה קישור שעושה בערך את זה: http://www.cs.grinnell.edu/~rebelsky/Courses/CS152/2006S/Outlines/outline.25.html

נקבל משהו כזה: http://ideone.com/BHypg
(העתקתי את Variable מהקישור, תיקנתי אצלו באג קטן, והתאמתי אותו ל-Swappable שלי).
זה לא נוח שצריך להשתמש ב-getValue() / setValue()‎ כל הזמן, אבל ככה זה בג'אווה...
ברגע שמסתיים הקוד שעושה המון החלפות, מוציאים את המשתנים מהאובייקטים שעוטפים אותם.

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

הסבר מעניין, תודה.

נכון אתם אנשים כשרים, אך לא לזאת הייתה כוונתי. רציתי שתהיו כחיות הנוהמות ביער לילות שלמים.

אין בעיה אחי, תבוא כל יום...

ציטוט:

פרמטרים עוברים בג'אווה by-value. אין דבר כזה "by-pointer". העניין הוא שג'אווה היא מהשפות המשעשעות שמתייחסות לטיפוסים פרימטיביים בצורה שונה מאשר לטיפוסים לא-פרימיטיביים. משתנים מטיפוסים פרימטיביים הם 'ערומים', בעוד משתנים מטיפוסים אחרים נגישים תמיד רק דרך reference אליהם.

אני לא יודע עד כמה זה משעשע, זה ללא ספק עושה את חיי המתכנת קלים יותר.. אוביקט? יופי הוא בהיפ..
פרמטיבי? בסטאק, אין *&*&.. אין דסטרקטורים.

יש גם הרבה דברים משעשעים מC++, כל הדיפולט-אופרטורס, והדיפולט קופי-קונסטרקטור, שבמקור נעשו בכדי לתת תאימות עם C, הם דברים מאוד משעשעים בC++.

קוד:

class T{
public:
	int* x;
	int getMyX(){return *x;}

	T(int x_){x=new int(x_);}
	virtual ~T(){delete x;}
};


	T t1(1);
	{
		T t2(2);
		t1=t2;
		cout<<t1.getMyX()<<"\n";
	}
	cout<<t1.getMyX()<<"\n";////what heppened to my x???	

ציטוט:

במקור נכתב על ידי The_Equivocator אני לא יודע עד כמה זה משעשע, זה ללא ספק עושה את חיי המתכנת קלים יותר..

באמת? קל יותר עם זה שמשתנים פרימיטיביים מתנהגים בצורה שונה משאר המשתנים בג'אווה? בגלל זה יש לנו את java.lang.Integer (בנוסף ל-int), את java.lang.Float (בנוסף ל-float), את java.lang.Long (בנוסף ל-long), וכו'? כן, הרבה יותר קל מאשר אם מראש היה לנו רק Integer, Float ו-Long בלבד, בלי האחים הקטנים שלהם...

ציטוט:

במקור נכתב על ידי The_Equivocator אוביקט? יופי הוא בהיפ..

מה זה משנה איפה הוא מאוחסן בזיכרון?

ציטוט:

במקור נכתב על ידי The_Equivocator פרמטיבי? בסטאק, אין *&*&.. אין דסטרקטורים.

הא?

ציטוט:

במקור נכתב על ידי The_Equivocator יש גם הרבה דברים משעשעים מC++, כל הדיפולט-אופרטורס, והדיפולט קופי-קונסטרקטור, שבמקור נעשו בכדי לתת תאימות עם C, הם דברים מאוד משעשעים בC++.

אתה בטוח שעשו את זה בשביל תאימות לאחור עם C? באמת בטוח?

לגבי הקוד שלך - נכתב על ידי אדם חסר ידע ב-CPP. כי מי שיודע CPP יודע ש:

• לא מנהלים את הזיכרון שלך בעצמך, אלא משתמשים ב-containers של STL ובמצביעים החכמים של boost.
• אם מנהלים את הזיכרון שלך בעצמך, עושים את זה כמו בזהירות, כמו בני-אדם.
• השלשה copy constructor, assignment operator ו-destructor בדרך-בכלל באה ביחד, ולכן אם יש אחד מהם, כנראה שצריך את שלושתם.
  (ראה גם: MEM41, וכמובן סעיפים רבים ב-Effective C++‎ ולא רק הבודד אליו מפנים בלינק הזה...)

ואגב, הוא בכלל לא מתקמפל...

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

פסטן, פסטן, פסטן..

ציטוט:

אתה בטוח שעשו את זה בשביל תאימות לאחור עם C? באמת בטוח?

אני לא בטוח, אבל קראתי מאמר בנושא.. לא זוכר איפה.

ציטוט:

לגבי הקוד שלך - נכתב על ידי אדם חסר ידע ב-CPP. כי מי שיודע CPP יודע ש: לא מנהלים את הזיכרון שלך בעצמך, אלא משתמשים ב-containers של STL ובמצביעים החכמים של boost. אם מנהלים את הזיכרון שלך בעצמך, עושים את זה כמו בזהירות, כמו בני-אדם.

LOL מצבעים חכמים של bost, אנשים שלומדים C++ משתמשים בזה? כל המטרה זה בלימוד. זה היה לגיטימי להגיד לו סמרט פונטרס היו חלק מהתקן של c++, והיו מובנים בכל ספירה של קומפיילר בי-דיפלוט.(יום יבוא, יום יבוא..)

ציטוט:

השלשה copy constructor, assignment operator ו-destructor בדרך-בכלל באה ביחד, ולכן אם יש אחד מהם, כנראה שצריך את שלושתם.

מקובל, אכן לו היה הדסטרקטור פועל על ריק, לא הייתה בעיה.

ציטוט:

ואגב, הוא בכלל לא מתקמפל...

כאן כבר הרגת אותי מצחוק.. ברור זו הייתה רק דוגמה, אתה רוצה את "הפרוייקט" המלא?
סיוט-יורסלף..

קוד:

#include <iostream>
#include "T.cpp"

using namespace std;




int main() {

	T t1(1);
	{
		T t2(2);
		t1=t2;
		cout<<t1.getMyX()<<"\n";
	}
	cout<<t1.getMyX()<<"\n";////what heppened to my x???

	return 0;
}


[CODE]
class T{
public:
	int* x;
	int getMyX(){return *x;}

	T(int x_){x=new int(x_);}
	virtual ~T(){delete x;}
};

ציטוט:

במקור נכתב על ידי The_Equivocator אני לא בטוח, אבל קראתי מאמר בנושא.. לא זוכר איפה.

אני קראתי מאמר שאומר שכל מה שכתבת זה שטויות. ההבדל הוא שאני הבאתי לינק למאמר הזה...

ציטוט:

במקור נכתב על ידי The_Equivocator LOL מצבעים חכמים של bost, אנשים שלומדים C++ משתמשים בזה? כל המטרה זה בלימוד. זה היה לגיטימי להגיד לו סמרט פונטרס היו חלק מהתקן של c++, והיו מובנים בכל ספירה של קומפיילר בי-דיפלוט.(יום יבוא, יום יבוא..)

המצביעים החכמים של boost כבר בתוך התקן, לידיעתך. לא רק שהם בתוך C++11, אלא שהם כבר היו ב-std::tr1. כמובן שכדי לדעת את זה, צריך לדעת CPP...
אנשים שלומדים CPP ממקור טוב בהחלט לומדים להשתמש ב-STL וב-smart pointer-ים המובנים.

ציטוט:

במקור נכתב על ידי The_Equivocator כאן כבר הרגת אותי מצחוק.. ברור זו הייתה רק דוגמה, אתה רוצה את "הפרוייקט" המלא? סיוט-יורסלף..

חחחחחחחחחחח

אבל זה לא קשור לזה שבקוד המקורי שלך לא היו סוגריים ליד הפונקציה getMyX והייתה חסרה נקודה-פסיק לפני שערכת... (וגם הקוד היה מיושר ימינה כדי שאי-אפשר יהיה לקרוא אותו ולראות את הטעות...)


בקיצור, לימדתי אותך קצת ג'אווה למעלה, ובמקום להגיד תודה אתה מתחיל להתווכח כדי שאני אלמד אותך גם CPP? גישה יצירתית למדי, אין ספק...

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

ציטוט:

אני קראתי מאמר שאומר שכל מה שכתבת זה שטויות. ההבדל הוא שאני הבאתי לינק למאמר הזה...

זה כבר וויכוח מטופש, יכול להיות שהמאמר היה גבב שטויות, ויכול להיות שלא, והאמת שזה לא כל-כך משנה..

ציטוט:

המצביעים החכמים של boost כבר בתוך התקן, לידיעתך. לא רק שהם בתוך C++11, אלא שהם כבר היו ב-std::tr1. כמובן שכדי לדעת את זה, צריך לדעת CPP... אנשים שלומדים CPP ממקור טוב בהחלט לומדים להשתמש ב-STL וב-smart pointer-ים המובנים.

כך, או אחרת, אחרת, או כך, מי שלומד C++, צריך ללכלך את היידים בניהול זכרון, רק כך לומדים באמת.
והוא חייב לדעת כיצד מתנהל זיכרון בשפה שבה הוא כותב, מאחורי הקלעים, הרבה ליפני שימוש בסמרט פויינטרים, כאשר אני רואה אנשים שמשתמשים בספריות סטרינג, ואין להם בעצם מושג קלוש מזה זה בעצם ה"סטרינג" הזה?? זה מעורר בעיה..

ציטוט:

אבל זה לא קשור לזה שבקוד המקורי שלך לא היו סוגריים ליד הפונקציה getMyX והייתה חסרה נקודה-פסיק לפני שערכת...

ובגלל זה ערכתי, אין לי מושג שהגבת על הודעה ליפני העריכה, אולי בסוף נוסיף לפורום איזה סינכרון, וננעל את הודעות המשתמש לחצי שעה?

ציטוט:

במקור נכתב על ידי The_Equivocator כך, או אחרת, אחרת, או כך, מי שלומד C++, צריך ללכלך את היידים בניהול זכרון, רק כך לומדים באמת. והוא חייב לדעת כיצד מתנהל זיכרון בשפה שבה הוא כותב, מאחורי הקלעים, הרבה ליפני שימוש בסמרט פויינטרים, כאשר אני רואה אנשים שמשתמשים בספריות סטרינג, ואין להם בעצם מושג קלוש מזה זה בעצם ה"סטרינג" הזה?? זה מעורר בעיה..

נכון. הוא צריך לדעת את זה.
אבל אם הוא כתב מחלקה שמנהלת זיכרון ידנית, ולא הגדיר לה copy constructor ו-assignment operator זה מוכיח שהוא לא יודע, אפילו שהוא צריך. אז מה זה מוכיח? שמי שלא יודע CPP, יכול לכתוב קוד CPP שקורס / פותח חולשת אבטחה / הרבה דברים רעים אחרים. אז מה?
מי שלא יודע ג'אווה יכתוב קדו גרוע בג'אווה ומי שלא יודע ARMv7 assembly יכתוב קוד גרוע באסמלי של ARM...

איך זה קשור לשאלה שלך על ג'אווה? לא ברור.
איך ההבדל בין טיפוסים פרימיטיביים ללא-פרימיטיביים בג'אווה "עושה את חיי המתכנת קלים יותר"? לא ענית.
איך כל סיפור ה-boxing יותר פשוט מכך שהטיפוסים היסודיים גם היו אובייקטים שיורשים מ-java.lang.Object? לא ענית.
מה בכלל משמעות ההתבטאות הבאה?

פרמטיבי? בסטאק, אין *&*&.. אין דסטרקטורים.

השד יודע. אתה טוען שלאובייקטים מקומיים ("בסטאק") לא נקראים ה-destructor-ים?! הזוי.

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

ציטוט:

השד יודע. אתה טוען שלאובייקטים מקומיים ("בסטאק") לא נקראים ה-destructor-ים?! הזוי.

מה הקשר? אלו משתנים אוטומטיים, מה שאמרתי זה די פשוט להבנה(לפחות כך חשבתי), בJAVA אין לך צורך לדאוג לדסטרקטורים(כי יש גרבג קולקטור), ואין סימנים בסגנון * ** *** &*, והשד יודע מה.

וזה שאובייקטים נוצרים תמיד בהיפ, ופרמטיביים בסטאק, זה בהחלט מפשט את הדברים.
עובדה שבכדי לתכנת בJAVA לא צריך בכלל לדעת(או לדעת מעט מאוד מאוד), שיש בכלל דברים כאלה סטאק והיפ, יש לך מילת קסם NEW, וזה בערך כל מה שמתכנת JAVA צריך לדעת.

בניגוד לכך כאשר מתכנת בC יוצר אובייקט ענק על המכסנית, ומעביר אותו בי וליו(דבר שהJAVA לא נותן לך מלכתחילה לעשות), זה בעייתי. אין כאן בכלל וויכוח, JAVA היא שפה הרבה יותר פשוטה, ורבים מהדברים שהיא מונעת ממך לעשות, אילו דברים שמתכנת נורמלי לא היה עושה גם ב++C.

ניהול זכרון זו רק דוגמה בודדת, מה פשרו של דיסטרקטור לא ווירטואלי אתה יכול להסביר לי?

ציטוט:

אתה טוען שלאובייקטים מקומיים ("בסטאק") לא נקראים ה-destructor-ים?! הזוי.

אגב, זה בדיוק מה שאני טוען.. ובדיוק בגלל זה כתבתי את הדוגמה שלי שבדיוק מסתמכת על העובדה הזו.. נכון? (או שלא?..)

על מה מתבססת הדוגמה לקוד שכתבתי? על זה שאחרי היציאה מהבלוק(סגירת אקטיבשן פריים, על האובייקט יופעל הדסטרקטור..).

ציטוט:

במקור נכתב על ידי The_Equivocator מה הקשר? אלו משתנים אוטומטיים, מה שאמרתי זה די פשוט להבנה(לפחות כך חשבתי), בJAVA אין לך צורך לדאוג לדסטרקטורים(כי יש גרבג קולקטור), ואין סימנים בסגנון * ** *** &*, והשד יודע מה.

וואלה. כנראה שזה פיצ'ר מיותר בג'אווה. סתם יש finalize...
אבל כן, הרבה יותר קל לכתוב try...finally בכל מקום במקום לדאוג שה-destructor יטפל בזה...

ציטוט:

במקור נכתב על ידי The_Equivocator וזה שאובייקטים נוצרים תמיד בהיפ, ופרמטיביים בסטאק, זה בהחלט מפשט את הדברים. עובדה שבכדי לתכנת בJAVA לא צריך בכלל לדעת(או לדעת מעט מאוד מאוד), שיש בכלל דברים כאלה סטאק והיפ, יש לך מילת קסם NEW, וזה בערך כל מה שמתכנת JAVA צריך לדעת.

חוץ מזה שזו טעות...
http://stackoverflow.com/questions/...2099726#2099726
הקישור מדגים קטע משעשע נוסף: מסתבר שמערך - אפילו של פרימיטיבים - הוא אובייקט ונשמר ביעני-heap.
אבל האמירה שלך בהחלט מוכיחה את עצמה, כדי להיות מתכנת ג'אווה לא צריך לדעת כמעט כלום. תמיד אפשר לבוא לפורום ולקבל תשובה...

ציטוט:

במקור נכתב על ידי The_Equivocator בניגוד לכך כאשר מתכנת בC יוצר אובייקט ענק על המכסנית, ומעביר אותו בי וליו(דבר שהJAVA לא נותן לך מלכתחילה לעשות), זה בעייתי. אין כאן בכלל וויכוח, JAVA היא שפה הרבה יותר פשוטה, ורבים מהדברים שהיא מונעת ממך לעשות, אילו דברים שמתכנת נורמלי לא היה עושה גם ב++C.

אם זה באמת היה בעייתי לאובייקט מסוים, היו עושים לו copy constructor פרטי, כך שאי-אפשר יהיה להעתיק אותו, ואז המשתמש שלא יודע CPP היה בא לפורום ושואל למה הקוד לא מתקמפל, והיו עונים לו בפורום, ומסבירים לו שהוא צריך להעביר רפרנס לאובייקט, או להשתמש ב-shared_ptr...

ציטוט:

במקור נכתב על ידי The_Equivocator אגב, זה בדיוק מה שאני טוען.. ובדיוק בגלל זה כתבתי את הדוגמה שלי שבדיוק מסתמכת על העובדה הזו.. נכון? (או שלא?..) על מה מתבססת הדוגמה לקוד שכתבתי? על זה שאחרי היציאה מהבלוק(סגירת אקטיבשן פריים, על האובייקט יופעל הדסטרקטור..).

נו, אז הוכחת שמי שלא יודע CPP יכול לכתוב קוד CPP שקורס? זה חידוש גדול לדעתך?

ושוב - כמובן שלא הסברת איך זה שלכל טיפוס פרימיטיבי בג'אווה יש אח-גדול שעוטף אותו, במקום שכל הטיפוסים ירשו מ-java.lang.Object עוזר למישהו?

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

ציטוט:

הקישור מדגים קטע משעשע נוסף: מסתבר שמערך - אפילו של פרימיטיבים - הוא אובייקט ונשמר ביעני-heap. אבל האמירה שלך בהחלט מוכיחה את עצמה, כדי להיות מתכנת ג'אווה לא צריך לדעת כמעט כלום. תמיד אפשר לבוא לפורום ולקבל תשובה..

נו ומי אמר שמערך הוא לא אובייקט? מה זה arr.length, מאיפה זה בא מהעץ? בוודאי שזה אובייקט, ואפשר לייצר כזה רק ע"י NEW.. (אם לא ידעת ליצן..)

ציטוט:

נו, אז הוכחת שמי שלא יודע CPP יכול לכתוב קוד CPP שקורס? זה חידוש גדול לדעתך?

זה מדגים את הטיפשות של הדברים שבCPP בונה בשבילך.. עדיף לו הדברים הללו לא היו באים בדיפלוט, ומאלצים אותך לכתוב אחד במקרה הצורך.

הנה רשימה של פרמטיבים בJAVA, כמה מפתיעה, אין שם איזכור למערך?!?!
http://docs.oracle.com/javase/tutor.../datatypes.html

מי שמדבר על ליצנים...

שאלת שאלה, קיבלת תשובה (יותר טובה ממה שמגיע לך), ואז פתחת ויכוח מטומטם של "ג'אווה השפה הכי טובה בעולם אפילו שהתחלתי ללמוד רק אתמול ואני לא יודע כלום".

מעניין למה כבר 10 הודעות אתה מתחמק מלהסביר למה לדעתך הגאונית זה "ללא ספק עושה את חיי המתכנת קלים יותר" שטיפוסים פרימטיביים בג'אווה חיים בעולם קטן משלהם, ואם רוצים לחבר אותם לשאר היקום, צריך לעטוף אותם באובייקטים מיוחדים, במקום שמראש נשתמש באובייקטים האלה? (כמו בפייתון, C#‎, ועוד ועוד ועוד)

יש לי השערה בעניין...

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

ציטוט:

מעניין למה כבר 10 הודעות אתה מתחמק מלהסביר למה לדעתך הגאונית זה "ללא ספק עושה את חיי המתכנת קלים יותר" שטיפוסים פרימטיביים בג'אווה חיים בעולם קטן משלהם, ואם רוצים לחבר אותם לשאר היקום, צריך לעטוף אותם באובייקטים מיוחדים, במקום שמראש נשתמש באובייקטים האלה? (כמו בפייתון, C#‎, ועוד ועוד ועוד)

רק לצורכי ייעלות, כאשר פתחו את JAVA, זו הייתה המחשבה, אין שום סיבה אחרת.

ציטוט:

ג'אווה השפה הכי טובה

אם תראה לי מקום אחד שבו טענתי משהו בסגנון "גאווה הכי טובה בעולם", תקבל שוקו בחינם.

ציטוט:

למה כבר 10 הודעות אתה מתחמק מלהסביר

אני עונה על מה שבה לי, לא רציתי לריב איתך באשכול הזה, אתה משום מה תמיד נגרר לוויכוחים, זה בטח עושה לך את זה..

JAVA זו שפה מעולה לנישה שהיא תופסת כיום, היא בטח לא מושלמת, ובטח שלא נתן בה לעשות הכל, זו בדיוק הסיבה למה אני עכשיו לומד C++, זה בטח לא בגלל שגאווה הכי טובה בעולם.

ציטוט:

במקור נכתב על ידי The_Equivocator רק לצורכי ייעלות, כאשר פתחו את JAVA, זו הייתה המחשבה, אין שום סיבה אחרת.

ניחוש נחמד. חשבת על זה לבד או שראית את זה בעוד מאמר שאין לך קישור אליו?
http://gbracha.blogspot.com/2009/05/original-sin.html
http://java.dzone.com/articles/woul...-better-without
(ועוד תלונה בנושא: http://developeraspirations.wordpre...itives-are-bad/)

ציטוט:

במקור נכתב על ידי The_Equivocator אני עונה על מה שבה לי, לא רציתי לריב איתך באשכול הזה, אתה משום מה תמיד נגרר לוויכוחים, זה בטח עושה לך את זה..

ברור. בגלל זה כשקיבלת ממני תשובה לשאלה שלך על ג'אווה, התחלת לכתוב שטויות על CPP...

טעות שלי. להבא אשתדל אזכור לא לענות לך.

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

ציטוט:

This was a conscious decision by Java's designers for performance reasons. Because of this, Java was not considered to be a pure object-oriented programming language. However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their wrapper class.

http://en.wikipedia.org/wiki/Java_%...ing_language%29

ציטוט:

I am an Oracle Certified Professional, Java Development Certified Professional, Author, and currently work as a Senior Database Administrator for The DBA Zone.

.

וזה מה שיש לאיש לומר בנושא..
http://www.idevelopment.info/data/P...tive_Types.html


מי צודק? אני לא יודע, אבל זה שיש איזה צטוט בפורום שהבאת לכאן, ואומר בדיוק ההפך לא אומר כלום.

However, as of Java 5.0, autoboxing enables programmers to proceed as if primitive types were instances of their wrapper class

איזה מזל שבקישורים שלי נותנים דוגמות ספציפיות לכך שזה לא נכון:

Of course the first argument someone will bring to me is the availability of Autoboxing that came with Java 1.5. Autoboxing will automatically convert a primitive to its Object counterpart and visa versa on the fly with no additional programming thought. Problem solved right? Well not exactly.

You see while base primitives can be converted automagically to Objects via autoboxing, primitive arrays cannot. Ok well sure they can be created and cast to an object, but the resulting object cannot be initiated via reflection. This is because the ‘class’ of a primitive array has no constructor since it’s not a real Object.

הפסקה הראשונה אומרת "אבל אז יבוא איזה חכם בלילה ויגיד לי שיש autoboxing", והפסקה השניה נותנת את התרחיש המדויק שבו סיפור הטיפוסיפ הפרימטיביים עדיין לא תואם כמו שצריך את שאר מערכת הטיפוסים של השפה.
אבל כדי לדעת את זה, צריך אשכרה לקרוא את מה שכתוב בקישורים שהבאתי...

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

זה לא שזה לא נכון, אלה שזה לא מדוייק, ובכל גירסה, יש שיפור בנושא. (מנסים לייצר מעטפת כמה שיותר דומה לאובייקט).

ומה לגבי הקישור השני, בחרת להתעלם?

ציטוט:

במקור נכתב על ידי The_Equivocator זה לא שזה לא נכון, אלה שזה לא מדוייק, ובכל גירסה, יש שיפור בנושא. (מנסים לייצר מעטפת כמה שיותר דומה לאובייקט).

אז למה שלא תתקן את אי-הדיוקים?

ציטוט:

במקור נכתב על ידי The_Equivocator ומה לגבי הקישור השני, בחרת להתעלם?

א. בחרתי להגיב לפני שערכת. אולי תלמד לחשוב לפני שאתה כותב, במקום כל פעם לכתוב שטות, ואז לערוך, ואז לערוך שוב, ואז לערוך עוד פעם, ולהמשיך לערוך...

ב. הקישור השני לא קשור לכלום. מי אמר שזה שכל הטיפוסי יהיו אובייקטים שיורשים מ-java.lang.Object אומר שחייבים ליצור אותך ב-heap וךא על המחסנית? קרא שוב את הקישורים שהבאתי למעלה וגם את זה: http://blog.juma.me.uk/2008/12/17/o...ation-overhead/

ג. כמו שאמר אדם נבון מאוד:

ציטוט:

במקור נכתב על ידי אדם נבון מאוד, רק חבל שהוא לא יודע לא C++‎, לא ג'אווה, ולא הרבה דברים אחרים... אני עונה על מה שבה לי, לא רציתי לריב איתך באשכול הזה, אתה משום מה תמיד נגרר לוויכוחים, זה בטח עושה לך את זה..

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

j

ציטוט:

ava.lang.Object אומר שחייבים ליצור אותך ב-heap וךא על המחסנית?

אף אחד לא אמר, אבל כך מסתדר ממש יופי, אובייקטים על ההיפ- פרמטיבים , על הסטאק..
זה בטח איזה קונפרציה שתגרום באונברסיטאות ללמד שבוע C++, בכדי לאמלל אותך בשאלות על זכרון.., כך היו מלמדים JAVA כל התואר וגמרנו..

רק מה כמה תופס בייט?
וכמה תופס OBJECT, אתה יודע?

ציטוט:

במקור נכתב על ידי The_Equivocator j אף אחד לא אמר, אבל כך מסתדר ממש יופי, אובייקטים על ההיפ- פרמטיבים , על הסטאק.. זה בטח איזה קונפרציה שתגרום באונברסיטאות ללמד שבוע C++, בכדי לאמלל אותך בשאלות על זכרון.., כך היו מלמדים JAVA כל התואר וגמרנו.. רק מה כמה תופס בייט? וכמה תופס OBJECT, אתה יודע?

עכשיו תקרא את הקישורים שהבאתי למעלה פעם שלישית. אולי third time's the charm ותבין...

העיקר שהבאת חפירה מהתחת שלא קשורה לשאלה ששאלת ולתשובה שקיבלת.

קראתי אותם כבר בהתחלה. (תאמין או לא)
והבנתי את השאלה שלך.

אבל יש לך כשל לוגי. אתה לא שם לב?
הקשור השני שנתתי(זה שאתה אומר שהוא אינו קשור), אומר

ציטוט:

This approach would be very costly for small and simple variables. Instead of create variables using new, Java can use primitive types to create automatic variables that are not references. The variables hold the value, and it's place on the stack so its much more efficient.

אבל OBJECT, הכי פשוט שאתה יכול לדמיין לעצמך זה שכולם יורשים ממנו בJAVA, אתה מבין שהוא לא נכנס לקטגוריה של small and simple?

(ואם הוא כבר לא כזה, אז למה לא להקצות אותו על ההיפ?, שהרי במקרה כזה העלות כבר זניחה).

רגע, תהיה עריכה? בינתיים יש לנו 8/18...
אני אחכה עוד מספר דקות לפני שאעז להגיב.

הו, רק כתבתי וזה נהיה 9/18...

בעריכה הבהרתי את מה שאמרתי, בדי לחסוך עוד תגובות.. אבל איתך זה לא עובד..

ציטוט:

For performance reasons, the designers of the Java language decided to include these primitive types

ציטוט:

Creating an object using new isn't very efficient because

אז אתה מבין יש לנו בעיה, הוא אומר שתאורטית הדבר היה אפשרי, אבל בגלל יעלות לא עשו, אם ההסברים שלך נכונים(בקשורים שנתת), אז מה פשר כל העמוד הזה שהאיש הקדיש לא מזמנו וכתב?

אז או שהוא טועה, ופסטן צודק, או שבכל זאת יש איזה קשר לייעלות.
בכל מקרה זה שאתה אומר שהמאמר לא קשור, מצביעה שלפחות אצלך קיים כשל לוגי..

ציטוט:

במקור נכתב על ידי The_Equivocator בעריכה הבהרתי את מה שאמרתי, בדי לחסוך עוד תגובות.. אבל איתך זה לא עובד.. אז אתה מבין יש לנו בעיה, הוא אומר שתאורטית הדבר היה אפשרי, אבל בגלל יעלות לא עשו, אם ההסברים שלך נכונים(בקשורים שנתת), אז מה פשר כל העמוד הזה שהאיש הקדיש לא מזמנו וכתב? אז או שהוא טועה, ופסטן צודק, או שבכל זאת יש איזה קשר לייעלות. בכל מקרה זה שאתה אומר שהמאמר לא קשור, מצביעה שלפחות אצלך קיים כשל לוגי..

הכשל היחיד הוא אצלך, והוא גם בלוגיקה, וגם בקריאה. יש לנו קישור אחר, מאותוריטה אמיתית, שמסביר שאפשר היה לעשות את זה בלי פגיעה של ממש בביצועים. מה פשר העמוד הזה? כמו שאתה מדבר שטויות, גם ההוא בעמוד שהבאת מדבר שטויות. יש הרבה אנשים שכותבים שטויות באינטרנט.

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.

עכשיו שבטוח שלא תהיה עריכה נוספת, אפשר להתייחס.

מה שכתבת זו שטות עצומה. הקומפיילר יכול לטפל בכל מה שצריך ב-compile-time, ולא תהיה שום השפעה על הביצועים. המקום היחיד שבו תהיה השפעה על הביצועים מכך ש-int יהיה טיפוס שיורש מ-java.lang.Object היא כשמתחילים לשחק עם פולימורפיזם, אבל אז יש השפעה על הביצועים גם במימוש הנוכחי - ממילא צריך לבצע boxing, ואז לשחק עם זה...

כל זה כמובן כתוב בלינק, כך שאיפול אם נאמין לך שקראת, אתה לא מבין כלום.

עכשיו, זה נחמד שהבאת לי איזה DBA שהוא גם "Java Development Certified Professional", וכל מה שיש לי זה "איזה צטוט בפורום" שהבאתי. אלא שהפוסט ההוא שהבאתי נכתב על-ידי אחד הארכיטקטים הראשיים של ג'אווה, והמחבר של ה-Java Language Specification ושל ה-Java Virtual Machine Specification.
הנה קו"ח שלו: http://bracha.org/cv.pdf
הנה ה-JLS וה-JVMS באתר אוראקל: http://docs.oracle.com/javase/specs/
פתח את ה-PDF-ים:

• http://docs.oracle.com/javase/specs/jls/se7/jls7.pdf
• http://docs.oracle.com/javase/specs/jvms/se7/jvms7.pdf

אז מה יש לנו בינתיים?
לא מבין בג'אווה. חושב שאיזה DBA אקראי עדיף על מי שכתב - מילולית, אשכרה כתב - את הספציפיקציות של ג'אווה. חופר על CPP בלי קשר. לא יודע מה זה std::vector. טוען ש"ת'רדים חוסכים קונקטסט-סוויוצ'ים" (זוכר את זה? כמה צחקתי אז...). לא מבין שפיצ'רים מאגניבים של השפה יכולים להיות מטופלים לגמרי ב-compile-time בלי להשפיע על ביצועי הריצה. ועוד, ועוד, ועוד...

השאלה היחידה היא למה אחרי ששאלת שאלה וקיבלת תשובה לא יכלת להגיד "תודה אחי", אלא היית חייב להתחיל לחפור על שטויות שבאופן מובהק אין לך מושג בהן? לא נמאס לך?

(קרדיט למרשי)
אמר לה ינאי מלכא לדביתיה אל תתיראי מן הפרושין ולא ממי שאינן פרושין אלא מן הצבועין שדומין לפרושין שמעשיהן כמעשה זמרי ומבקשין שכר כפנחס
אמר פסטן: שניהם גרועים, אבל עדיף להיות טיפש מאשר שקרן.