posts - 3,  comments - 6,  trackbacks - 0
  2010年8月29日
#include <stdio.h>
#include 
<stdlib.h>
#include 
<string.h>

#define SetSize 256 //字符集大小

//说明:查找字符串中字符间不同的最大子串
//参数:string 待搜索字符串
//        rst 存放找到的最大子串
//返回:找到最大子串长度
int findMaxSubstring(const char *stringchar *rst){

    
const char *= string;
    
const char *substring = p;        //当前子串
    int length = 0;                //当前子串长度   
    const char *maxSubstring = substring;    //已经找到的最大子串
    int maxLength = 0;                //已经找到的最大子串长度

    
// 遍历字符串过程中,字符最后一次出现的位置
    const char* position[SetSize];
    memset(position, 
0, SetSize * sizeof(char *));

    
char ch;    //
    while ((ch = *p) != '\0')
    
{          
        
if (position[ch] < substring){  //字符在当前子串首次出现   
            length++;
            
if (length > maxLength){   
                maxSubstring 
= substring;
                maxLength 
= length;   
            }
   
        }
   
        
else {
            substring 
= position[ch] + 1;    //当前子串从该字符上次出现的位置后面开始
            length = p - position[ch];
        }


        position[ch] 
= p; // 保存字符的位置
        p++;    
    }


    
// 拷贝找到的最大子串
    strncpy(rst, maxSubstring, maxLength);
    rst[maxLength] 
= '\0';
    
return maxLength;   
}
 



据说这是微软面试题。


posted @ 2010-08-29 17:30 custa 阅读(429) | 评论 (0)编辑 收藏
  2010年8月22日

代码1
const int size = 9;
char c[size];

1.VS2005 编译为 C 代码(/TC)
编译不通过
错误 1 error C2057: expected constant expression
错误 2 error C2466: cannot allocate an array of constant size 0
错误 3 error C2133: 'c' : unknown size

2.VS2005 编译为 C++ 代码(/TP)
编译通过

3.Cygwin gcc/g++
编译通过

================================================
代码2
int temp = 9;
const int size = temp;
char c[size];


1.VS2005 编译为 C 代码(/TC)
编译不通过
错误 1 error C2057: expected constant expression
错误 2 error C2466: cannot allocate an array of constant size 0
错误 3 error C2133: 'c' : unknown size

2.VS2005 编译为 C++ 代码(/TP)
编译不通过
错误 1 error C2057: expected constant expression
错误 2 error C2466: cannot allocate an array of constant size 0
错误 3 error C2133: 'c' : unknown size


3.Cygwin gcc/g++
编译通过

================================================
代码3
int size;
scanf("%d", &size);
char c[size];

1.Cygwin gcc/g++
编译通过
但不能对数组初始化。

2.VS2005
编译不通过


posted @ 2010-08-22 16:25 custa 阅读(1716) | 评论 (3)编辑 收藏
  2010年8月15日

今天看《C++ Primer》的成员访问操作符。看重载箭头操作符部分,刚开始有点迷茫,看了两遍总算有点理解,把心得写在这,与各位分享,如果有错误欢迎指正。
箭头操作符(->)的通常用法是,使用一个类对象的指针来调用该指针所指对象的成员。左操作数为对象指针,右操作数为该对象的成员。定义重载箭头操作符之后看起来就有点特别,可以用类对象的指针来调用,也可以用类对象直接调用。
重载箭头操作符,首先重载箭头操作符必须定义为类成员函数。
箭头操作符可能看起来是二元操作符:接受一个对象和一个成员名,对对象解引用以获取成员。其实箭头操作符是一元操作符,没有显示形参(而且是类成员,唯一隐式形参是this)。->的右操作数不是表达式,而是对应类成员的一个标识符,由编译器处理获取成员工作(编译器对重载箭头操作符所做的事情,比其它重载操作符要多,这里也正是复杂的地方)。
下面这一段是《C++ Primer》重载箭头操作符的内容。

----------------------------------------华丽分割线----------------------------------------
重载箭头操作符
箭头操作符与众不同。它可能表现得像二元操作符一样:接受一个对象和一个成员名。对对象解引用以获取成员。不管外表如何,箭头操作符不接受显式形参。
这里没有第二个形参,因为 -> 的右操作数不是表达式,相反,是对应着类成员的一个标识符。没有明显可行的途径将一个标识符作为形参传递给函数,相反,由编译器处理获取成员的工作。

当这样编写时:
     point->action();

由于优先级规则,它实际等价于编写:
     (point->action)();
换句话说,我们想要调用的是对 point->action 求值的结果。编译器这样对该代码进行求值:

1.如果 point 是一个指针,指向具有名为 action 的成员的类对象,则编译器将代码编译为调用该对象的 action 成员。

2.否则,如果 point(注:中文版误写为action) 是定义了 operator-> 操作符的类的一个对象,则 point->action 与 point.operator->()->action 相同。即,执行 point 的 operator->(),然后使用该结果重复这三步。

3.否则,代码出错。

对重载箭头的返回值的约束
重载箭头操作符必须返回指向类类型的指针,或者返回定义了自己的箭头操作符的类类型对象。

如果返回类型是指针,则内置箭头操作符可用于该指针,编译器对该指针解引用并从结果对象获取指定成员。如果被指向的类型没有定义那个成员,则编译器产生一个错误。
如果返回类型是类类型的其他对象(或是这种对象的引用),则将递归应用该操作符。编译器检查返回对象所属类型是否具有成员箭头,如果有,就应用那个操作符;否则,编译器产生一个错误。这个过程继续下去,直到返回一个指向带有指定成员的的对象的指针,或者返回某些其他值,在后一种情况下,代码出错。
----------------------------------------华丽分割线----------------------------------------
如果上面分割线之间的内容看懂了,下面的也就不用看了哈。
根据理解,定义了3个类,C包含B,B包含A。A、B、C都定义了一个action的成员函数。B和C都重载箭头操作符,不同的是B的重载箭头操作符返回的是A类对象的指针,而C的重载箭头操作符返回的是B类对象。

#include <iostream>   
using namespace std;   
  
class A{   
public:   
    
void action(){   
        cout 
<< "Action in class A!" << endl;   
    }
   
}
;   
  
class B{   
    A a;   
public:   
    A
* operator->(){   
        
return &a;   
    }
   
    
void action(){   
        cout 
<< "Action in class B!" << endl;   
    }
   
}
;   
  
class C{   
    B b;   
public:   
    B 
operator->(){   
        
return b;   
    }
   
    
void action(){   
        cout 
<< "Action in class C!" << endl;   
    }
   
}
;   
  
int main(int argc, char *argv[])   
{   
    C
* pc = new C;   
    pc
->action();   
    C c;   
    c
->action();    
    getchar();   
    
return 0;   
}
  
#include 
<iostream>
using namespace std;

class A{
public:
 
void action(){
  cout 
<< "Action in class A!" << endl;
 }

}
;

class B{
 A a;
public:
 A
* operator->(){
  
return &a;
 }

 
void action(){
  cout 
<< "Action in class B!" << endl;
 }

}
;

class C{
 B b;
public:
 B 
operator->(){
  
return b;
 }

 
void action(){
  cout 
<< "Action in class C!" << endl;
 }

}
;

int main(int argc, char *argv[])
{
 C
* pc = new C;
 pc
->action();
 C c;
 c
->action(); 
 getchar();
 
return 0;
}
 


上面代码输出结果是:
Action in class C!
Action in class A!

其中的代码
C* pc = new C;
pc->action();
输出的结果是
Action in class C!
这个结果比较好理解,pc是类对象指针,此时的箭头操作符使用的是内置含义,对pc解引用然后调用对象的成员函数action。

而下面的代码
C c;
c->action();

输出的结果是
Action in class A!
其实c->action();的含义与c.operator->().operator->()->action();相同。

c是对象,c后面的箭头操作符使用的是重载箭头操作符,即调用类C的operator->()成员函数。此时返回的是类B的对象,所以调用类B的operator->()成员函数,B的operator->()返回的是指针,所以现在可以使用内置箭头操作符了。对B的operator->()返回的指针进行解引用,然后调用解引用后的对象的成员函数action,此时调用的就是类A的action()。这里存在一个递归调用operator->()的过程,最后再使用一次内置含义的箭头操作符。

posted @ 2010-08-15 13:20 custa 阅读(2063) | 评论 (3)编辑 收藏
仅列出标题