char * s = const_cast<char *>(str);
s[0] = 'A';
cout<<s<<endl; //输出Abc
但是q样׃行了(jin)Q?
const char *str = "abc";
char * s = const_cast<char *>(str);
s[0] = 'A';
cout<<s<<endl; //~译能通过Q但是执行就报错?br />
: const char str[] = "abc"; abc存储在堆栈中Q?/font>
: const char *str = "abc"; abc存储在静(rn)态存储区Q?/font>
准确的说Q上面两?#8220;abc"都是存储在静(rn)态存储区Q即帔R区。常量区是可M可写的。所以Q何试囑֯帔R行写的操作都是非法的Q当然了(jin)Q这也不是一定不可写的，你可以采取某U渠道改变常量区的内存属性，比如改变pe相关节的属性就可以对常量区q行dQ当然了(jin)Q这个目前可以忽略。。?
那么Z么str[] = "abc"; 可以写呢Q答案就在str[] = "abc";?x)有一个额外的拯q程Q即把常量区?"abc"拯到栈内存去，所以就可以写了(jin)?
Frank_Fang 2009-08-05 16:57 发表评论
]]>Frank_Fang 2009-05-30 00:22 发表评论
]]>static关键字有两种意?你看上下文来判断
1,表示变量是静(rn)态存储变?
表示变量存放在静(rn)态存储区.
2,表示该变量是内部q接
(q种情况是指该变量不在Q何{}之内,p全局变量那样,q时候加上static)
,也就是说在其它的.cpp文g?该变量是不可见的(你不能用).
当static加在函数前面的时?
表示该函数是内部q接,之在本文件中有效,别的文g中不能应用该函数.
不加static的函数默认ؓ(f)是全局?
也就是说在其他的.cpp中只要申明一下这个函?可以用它.
1、static全局变量与普通的全局变量有什么区别？static局部变量和普通局部变量有什么区别？static函数与普通函数有什么区别？
{：(x)全局变量(外部变量)的说明之前再冠以static 构成了(jin)?rn)态的全局变量。全局变量本n是?rn)态存储方式， ?rn)态全局变量当然也是?rn)态存储方式?q两者在存储方式上ƈ无不同。这两者的区别虽在于非?rn)态全局变量的作用域是整个源E序Q当一个源E序由多个源文gl成Ӟ非静(rn)态的全局变量在各个源文g中都是有效的?而静(rn)态全局变量则限制了(jin)其作用域Q?卛_在定义该变量的源文g内有效， 在同一源程序的其它源文件中不能使用它。由于静(rn)态全局变量的作用域局限于一个源文g内，只能源文件内的函数公用， 因此可以避免在其它源文g中引起错误?br />
从以上分析可以看出， 把局部变量改变(sh)ؓ(f)?rn)态变量后是改变(sh)(jin)它的存储方式x变(sh)(jin)它的生存期。把全局变量改变?sh)?rn)态变量后是改变(sh)(jin)它的作用域， 限制?jin)它的用范围?br />
static函数与普通函C用域不同。static函数仅在本文件中使用。只在当前源文g中用的函数应该说明为内部函?static)Q内部函数应该在当前源文件中说明和定义。对于可在当前源文g以外使用的函敎ͼ应该在一个头文g中说明，要用这些函数的源文件要包含q个头文?br />
static全局变量与普通的全局变量有什么区别：(x)static全局变量只初使化一ơ，防止在其他文件单元中被引?
static局部变量和普通局部变量有什么区别：(x)static局部变量只被初始化一ơ，下一ơ依据上一ơ结果|
static函数与普通函数有什么区别：(x)static函数在内存(sh)只有一份，普通函数在每个被调用中l持一份拷?/p>
2、如何引用一个已l定义过的全局变量Q?/strong>
{：(x)extern
可以用引用头文g的方式，也可以用extern关键字，如果用引用头文g方式来引用某个在头文件中声明的全局变理Q假定你那个变写错?jin)，那么在编译期??x)报错，如果你用extern方式引用Ӟ假定你犯?jin)同L(fng)错误Q那么在~译期间不会(x)报错Q而在q接期间报错?/p>
3、全局变量可不可以定义在可被多?C文g包含的头文g中？Z么？
{：(x)可以Q在不同的C文g中以static形式来声明同名全局变量?br />
可以在不同的C文g中声明同名的全局变量Q前提是其中只能有一个C文g中对此变量赋初|此时q接不会(x)出错?/p>
Frank_Fang 2009-05-29 23:20 发表评论
]]>Frank_Fang 2009-05-15 20:14 发表评论
]]>Frank_Fang 2009-05-15 19:16 发表评论
]]>条款31: 千万不要q回局部对象的引用Q也不要q回函数内部用new初始化的指针的引?/strong>
1 #include<iostream>
2 #include<string>
3
4 using namespace std;
5
6 class SimpleCat
7 {
8 public:
9 SimpleCat(void);
10 SimpleCat(int age,int weight);
11 int GetAge(){return itsAge;}
12 int GetWeight(){return itsWeight;}
13
14 private:
15 int itsAge;
16 int itsWeight;
17 //int itsAge=5;//1>.\SimpleCat.cpp(14) : error C2864: “SimpleCat::itsAge”: 只有?rn)态常量整型数据成员才可以在类中初始化
18
19 public:
20 virtual ~SimpleCat(void);
21 };
22
23 SimpleCat::SimpleCat(void)
24 {
25 cout<<"SimpleCat constructor "<<this<<endl;
26 }
27
28 SimpleCat::SimpleCat(int age,int weight)
29 {
30 cout<<"SimpleCat constructor "<<this<<endl;
31 itsAge = age;
32 itsWeight = weight;
33 }
34
35 SimpleCat::~SimpleCat(void)
36 {
37 cout<<"SimpleCat destructor"<<this<<endl;
38 }
39
40 SimpleCat &TheFunction();
41
42 int main()
43 {
44 SimpleCat myCat;
45 cout<<myCat.GetAge()<<endl;//q个值区别于java不是赋初gؓ(f)0?而是一个随机的?br /> 46 // cout<<myCat.itsAge<<endl;
47
48 cout<<"------------------------"<<endl;
49 SimpleCat &rCat = TheFunction();
50 int age = rCat.GetAge();
51 cout<<"rCat is "<<age<<"yeas old!"<<endl;
52 cout<<"&rCat: "<<&rCat<<endl;
53 SimpleCat *pCat = &rCat;
54 //delete rCat;//不能对引用用delete
55 delete pCat;
56 //delete好像没有释放内存Q怎么获取的还是原来的?br /> 57 //可能在这个内存区域存攄q是原来?先new string后再调用也没变，与编译器有关q是什??
58 for(int i =0;i<10;i++)
59 {
60 //想通过创徏string对象来填充之前的内存区间Q好像没?/span>
61 string *s = new string("abcdefghijklmn");
62 }
63
64 //q时问题来了(jin),rCat.getAge()?23?/span>
65 SimpleCat *pSecond = new SimpleCat(123,444);
66
67 cout<<"delete pCat后再使用rCat引用?x)发生什么问???"<<endl;
68 cout<<"delete pCat?nbsp;&rCat"<<&rCat<<endl;
69 cout<<"delete pCat?nbsp;rCat.age"<<rCat.GetAge()<<endl;
70
71 cout<<"--------------------------"<<endl;
72 SimpleCat myCat2 = TheFunction();//q个?x)发生内存泄漏，在函C甌的内存(sh)(x)得不到释?br /> 73 //myCat2是通过默认的拷贝函数来q行初始化的
74 cout<<"myCat2的地址?nbsp;"<<&myCat2<<endl;
75 return 0;
76 }
77
78
79 //q个函数在返回时Q是否会(x)创徏一个(f)时引用变???
80 //TheFunctionTwo(SimpleCat &simpleCat)q个函数在传递参数时是否?x)创Z个(f)时的引用变量
81 //临时的引用变量的作用域范围是什?/span>
82 SimpleCat &TheFunction()
83 {
84 SimpleCat *pFrisky = new SimpleCat(5,9);
85 cout<<"pFrisky: "<<pFrisky<<endl;
86 return *pFrisky;
87 }
88
89
90
2 #include<string>
3
4 using namespace std;
5
6 class SimpleCat
7 {
8 public:
9 SimpleCat(void);
10 SimpleCat(int age,int weight);
11 int GetAge(){return itsAge;}
12 int GetWeight(){return itsWeight;}
13
14 private:
15 int itsAge;
16 int itsWeight;
17 //int itsAge=5;//1>.\SimpleCat.cpp(14) : error C2864: “SimpleCat::itsAge”: 只有?rn)态常量整型数据成员才可以在类中初始化
18
19 public:
20 virtual ~SimpleCat(void);
21 };
22
23 SimpleCat::SimpleCat(void)
24 {
25 cout<<"SimpleCat constructor "<<this<<endl;
26 }
27
28 SimpleCat::SimpleCat(int age,int weight)
29 {
30 cout<<"SimpleCat constructor "<<this<<endl;
31 itsAge = age;
32 itsWeight = weight;
33 }
34
35 SimpleCat::~SimpleCat(void)
36 {
37 cout<<"SimpleCat destructor"<<this<<endl;
38 }
39
40 SimpleCat &TheFunction();
41
42 int main()
43 {
44 SimpleCat myCat;
45 cout<<myCat.GetAge()<<endl;//q个值区别于java不是赋初gؓ(f)0?而是一个随机的?br /> 46 // cout<<myCat.itsAge<<endl;
47
48 cout<<"------------------------"<<endl;
49 SimpleCat &rCat = TheFunction();
50 int age = rCat.GetAge();
51 cout<<"rCat is "<<age<<"yeas old!"<<endl;
52 cout<<"&rCat: "<<&rCat<<endl;
53 SimpleCat *pCat = &rCat;
54 //delete rCat;//不能对引用用delete
55 delete pCat;
56 //delete好像没有释放内存Q怎么获取的还是原来的?br /> 57 //可能在这个内存区域存攄q是原来?先new string后再调用也没变，与编译器有关q是什??
58 for(int i =0;i<10;i++)
59 {
60 //想通过创徏string对象来填充之前的内存区间Q好像没?/span>
61 string *s = new string("abcdefghijklmn");
62 }
63
64 //q时问题来了(jin),rCat.getAge()?23?/span>
65 SimpleCat *pSecond = new SimpleCat(123,444);
66
67 cout<<"delete pCat后再使用rCat引用?x)发生什么问???"<<endl;
68 cout<<"delete pCat?nbsp;&rCat"<<&rCat<<endl;
69 cout<<"delete pCat?nbsp;rCat.age"<<rCat.GetAge()<<endl;
70
71 cout<<"--------------------------"<<endl;
72 SimpleCat myCat2 = TheFunction();//q个?x)发生内存泄漏，在函C甌的内存(sh)(x)得不到释?br /> 73 //myCat2是通过默认的拷贝函数来q行初始化的
74 cout<<"myCat2的地址?nbsp;"<<&myCat2<<endl;
75 return 0;
76 }
77
78
79 //q个函数在返回时Q是否会(x)创徏一个(f)时引用变???
80 //TheFunctionTwo(SimpleCat &simpleCat)q个函数在传递参数时是否?x)创Z个(f)时的引用变量
81 //临时的引用变量的作用域范围是什?/span>
82 SimpleCat &TheFunction()
83 {
84 SimpleCat *pFrisky = new SimpleCat(5,9);
85 cout<<"pFrisky: "<<pFrisky<<endl;
86 return *pFrisky;
87 }
88
89
90
函数TheFunction()的返回D赋值给对SimpleCatcȝ一个引?然后使用q个引用来获得对象的成员变量age的?br /> Z(jin)证明函数TheFunction()在自由存储区中创建的对象被赋l了(jin)函数main()声明的引用，对rCat采取取址q算Q很明显Q它昄?jin)其引用的对象的地址Qƈ且和自由存储Z的对象的地址相匹配?br /> q一切看上去都很正确Q但是如何释放被占用的内存，对于引用是不能用deleteq算W的Q一个笔记聪明的Ҏ(gu)是声明另一个指针，q用由rCat得到的地址对它q行初始化。这样做实可以释放内存Q避免了(jin)内存的泄漏，但是存在一个小问题Q在delete pCat后，rCat引用又代表什么呢Q？引用必须是一个实际对象的别名Q如果引用一个空对象的话Q现在就是这U情况）(j)那么E序是无效的。?/p>
注意Q不能过分去一个用对I对象的引用的程序，也行能通过~译Q但是即使程序通过?jin)编译，它仍然是病态的Q而且执行l果也是不可预料?/p>
关于q个问题Q存在这3U解x?br />
W?U是在第49行声明一个SimpleCatcd象，然后从函数TheFunction()中采取g递的方式q回它的局部对象，q时不能在自由存储区来分配对象空_(d)不能使用newQ?br />
W?U是在函数TheFunction()中声明一个位于自由存储区中的SimpleCatcȝ对象Q但是让函数q回一个指向内存区域的指针Q然后完成对对象的操作，调用函数可以删除q个指针
W?U可行的Ҏ(gu)Q也是正的Q是在调用函C声明对象Q然后通过引用的方式把它传递给函数TheFunction()
也意呛_main函数中不能这样用了(jin)
Frank_Fang 2009-05-11 23:01 发表评论
]]>Person.java
class Person
{
public String name = "not know";//4
public int age = -1 ;//5
public Person()
{
}
public Person(String name , int age)//3
{
this.name = name ;//6
this.age = age;//7
}
public void showInfo()
{
System.out.println("Name is :"+name+" Age is :"+age);
}
}
class Student extends Person
{
public String school = "not konwn";//8
public Student()
{
super();
}
public Student (String name ,int age, String school) //1
{
super(name,age); //2
this.school = school;//9
}
public void showInfo()
{
super.showInfo();
System.out.println("School is :"+school);
}
}
AllTest.java
class AllTest
{
public static void main(String[]args)
{
Student stA = new Student("wanghao",20,"qinghuadaxue"); //0
}
}
其语句的执行序是怎样的呢Q?/span>
java中，在?/span>new操作W创Z个类的实例对象的时候，开始分配空间ƈ成员变量初始化?/span>默认?/span>数?/span>Q注意这里ƈ不是指将变量初始化ؓ(f)在变量定义处的初始|?strong>是给整Ş赋?/span>0Q给字符串赋?/span>null q一点于C++不同Q（student.name = null , student.age = 0 Q?/span>
然后在进入类的构造函数?/span>
在构造函数里面，首先要检查是否有this或?/span>super调用Q?/span>this调用是完成本cLw的构造函C间的调用Q?/span>super调用是完成对父类的调用?strong>二者只能出C个，q且只能作ؓ(f)构造函数的W一句出现?/span>在调?/span>this?/span>super的时候实现程序的跌{Q{而执行被调用?/span>this构造函数或?/span>super构造函数?/span>
?/span>this?/span>super执行完毕Q?strong>E序转而执行在cd义的时候进行的变量初始化工?/span>?/span>
q个执行完毕Q才是构造函C剩下的代码的执行?/span>
执行序已经用绿色标出?/span>
Order of initialization
Within a class, the order of initialization is determined by the order that the variables are defined within the class. The variable definitions may be scattered throughout and in between method definitions, but the variables are initialized before any methods can be called—even the constructor. For example: Feedback
//: c04:OrderOfInitialization.java
// Demonstrates initialization order.
import com.bruceeckel.simpletest.*;
// When the constructor is called to create a
// Tag object, you'll see a message:
class Tag {
Tag(int marker) {
System.out.println("Tag(" + marker + ")");
}
}
class Card {
Tag t1 = new Tag(1); // Before constructor
Card() {
// Indicate we're in the constructor:
System.out.println("Card()");
t3 = new Tag(33); // Reinitialize t3
}
Tag t2 = new Tag(2); // After constructor
void f() {
System.out.println("f()");
}
Tag t3 = new Tag(3); // At end
}
public class OrderOfInitialization {
static Test monitor = new Test();
public static void main(String[] args) {
Card t = new Card();
t.f(); // Shows that construction is done
monitor.expect(new String[] {
"Tag(1)",
"Tag(2)",
"Tag(3)",
"Card()",
"Tag(33)",
"f()"
});
}
} ///:~
//: c04:StaticInitialization.java
// Specifying initial values in a class definition.
class Bowl {
Bowl(int marker) {
System.out.println("Bowl(" + marker + ")");
}
void f(int marker) {
System.out.println("f(" + marker + ")");
}
}
class Table {
static Bowl b1 = new Bowl(1);
Table() {
System.out.println("Table()");
b2.f(1);
}
void f2(int marker) {
System.out.println("f2(" + marker + ")");
}
static Bowl b2 = new Bowl(2);
}
class Cupboard {
Bowl b3 = new Bowl(3);
static Bowl b4 = new Bowl(4);
Cupboard() {
System.out.println("Cupboard()");
b4.f(2);
}
void f3(int marker) {
System.out.println("f3(" + marker + ")");
}
static Bowl b5 = new Bowl(5);
}
public class StaticInitialization {
static Test monitor = new Test();
public static void main(String[] args) {
System.out.println("Creating new Cupboard() in main");
new Cupboard();
System.out.println("Creating new Cupboard() in main");
new Cupboard();
t2.f2(1);
t3.f3(1);
monitor.expect(new String[] {
"Bowl(1)",
"Bowl(2)",
"Table()",
"f(1)",
"Bowl(4)",
"Bowl(5)",
"Bowl(3)",
"Cupboard()",
"f(2)",
"Creating new Cupboard() in main",
"Bowl(3)",
"Cupboard()",
"f(2)",
"Creating new Cupboard() in main",
"Bowl(3)",
"Cupboard()",
"f(2)",
"f2(1)",
"f3(1)"
});
}
static Table t2 = new Table();
static Cupboard t3 = new Cupboard();
} ///:~
l承情况下的初始?br />
?jin)解一下包括承在内的初始化的q程是非常有益的，q样p有个?br />
体的?jin)解。看看下面这D代码：(x)
//: c06:Beetle.java
// The full process of initialization.
class Insect {
protected static Test monitor = new Test();
private int i = 9;
protected int j;
Insect() {
System.out.println("i = " + i + ", j = " + j);
j = 39;
}
private static int x1 = print("static Insect.x1 initialized");
static int print(String s) {
System.out.println(s);
return 47;
}
}
public class Beetle extends Insect {
private int k = print("Beetle.k initialized");
public Beetle() {
System.out.println("k = " + k);
System.out.println("j = " + j);
}
private static int x2 = print("static Beetle.x2 initialized");
public static void main(String[] args) {
System.out.println("Beetle constructor");
Beetle b = new Beetle();
monitor.expect(new String[] {
"static Insect.x1 initialized",
"static Beetle.x2 initialized",
"Beetle constructor",
"i = 9, j = 0",
"Beetle.k initialized",
"k = 47",
"j = 39"
});
}
} ///:~
你寻扄~译?/span>Beetle cȝ代码(也就?/span>Beetle.class 文g)。在装蝲的过E中Q装载器注意到它有一个基c?/span>(也就?/span>extends 所要表C的意?/span>)Q于是它再装载基cR不你创不创徏基类对象Q这个过EM(x)发生?/span>(试试看，把创建对象的那句注释掉，看看?x)有什么结果?/span>)如果基类q有基类Q那么这W二个基cM?x)被装蝲Q以此类?span style="color: blue">?strong>下一步，它会(x)执行“根基c?/strong>(root bas e class)”(q里是Insect)?/span>static 初始化，然后是下一个派生类?/span>static 初始化，以此cL。这个顺序非帔R要，因ؓ(f)zcȝ“?rn)态初始化(卛_面讲?/span>static 初始?/span>)”有可能要依赖基类成员的正初始化?/span>
现在所有必要的c都已经装蝲l束Q可以创建对象了(jin)?/span>首先Q对象里的所有的primitive 都会(x)被设成它们的~省|?/span>reference 也会(x)被设?/span>null——这个过E是一瞬间完成的，对象的内存(sh)(x)被统一地设|成“两进制的?/span>(binary zero)”?strong>如果有对成员变量赋初|则对成员变量q行赋|然后调用基类的构造函数。调用是自动发生的，但是你可以?/span>super 来指定调用哪个构造函?/span>(也就Beetle( )构造函数所做的W一件事)。基cȝ构造过E以?qing)构造顺序，同派生类的相同。基cL造函数运行完毕之后，?x)按照各个变量的字面序q行初始化。最后会(x)执行构造函数的其余部分?/span>
Frank_Fang 2009-05-11 21:16 发表评论
]]>在不向下转型的情况下是否能够直接q样调用funOne(*p)
占位
指针Q引用，对象
Frank_Fang 2009-05-10 21:13 发表评论
]]>C++中的成员变量的初始化序Q主要是内置cd的变量是否给其赋初g(jin)
C++中的内置cdprimitive在全局区域Q注意什么是全局区域)是会(x)被系l自动初始化??,在局部区域是不会(x)被自动初始化?br /> C++中的cȝ型的变量是会(x)被自动初始化的，但要求其有默认的构造函?br /> l承时C++的成员变量与Java中类?
Frank_Fang 2009-05-10 21:07 发表评论
]]>Frank_Fang 2009-05-08 10:15 发表评论
]]>Frank_Fang 2009-05-07 15:10 发表评论
]]>Frank_Fang 2009-05-07 14:20 发表评论
]]>Frank_Fang 2009-05-07 14:08 发表评论
]]>