第十三周上机

第一题

这个很简单，就给大家看看代码就好

• class.cpp

class Circle{
      int x,y,r;
      public:
      Circle(int a, int b, int c):x(a),y(b),r(c){}
      void getO(int &a, int &b){a=x;b=y;};
      int getR(){return r;}
      void move(int a, int b){x+=a;y+=b;}
      void setR(int c){r=c;}
  };

第二题

从这一题开始，我们就需要考虑析构函数的问题了，一般来说，涉及到自己申请内存的题目往往需要自己设置析构将内存释放，否则会造成内存泄漏的问题。那么一个问题就诞生了，delete是不能用于系统分配的内存的，所以，如果我们不给类中涉及到动态分配内存的变量赋初值，那么系统会给他一个默认值，这种情况下,当你在其他比如说构造拷贝函数里面delete原来申请的空间的时候就可能会发生错误，比较恶心的是头歌还不会报错，只是程序直接退出。
针对上面这个问题，比较有效的方法就是给涉及到动态空间分配的变量赋初值为NULL，要调用delete的时候就先判空，这样即可规避delete了系统分配内存的问题。

---

• 有关于栈的算法。其实并没有多难[一种实现栈的方法]（http://t.csdnimg.cn/dPFKY）
  主要是设计好栈顶是啥，是指向栈顶元素还是指向下一个元素应该存放的位置，确定好之后再做分析
  //头文件的修改就让同学们自己做即可

#include <iostream>
#include "class.h"
using namespace std;
mystack::mystack(int num=100)
{
    pointer=new int [num];    
    upOfStack=pointer-1;
    Size=num;
}
bool mystack::isempty()
{
    if (upOfStack==(pointer-1))
    {
        return true;
    }
    else return false;
}
bool mystack::isfull()
{
    if (upOfStack-pointer==(Size-1))
    {
        return true;
    }
    else return false;
}
bool mystack::push(int i)
{
    if (upOfStack-pointer<(Size-1))
    {   upOfStack++;
        *upOfStack=i;
        return true;
    }
    else return false;
}
bool mystack::pop(int &data)
{
    if (upOfStack>=pointer)
    {
        data=*upOfStack;
        upOfStack--;
        return true;
    }
    else return false;
}

第三题

这个题目就和之前说的，注意初始化，另外还有个就是类中的使用，当我们在函数中需要返回一个String类型的，有时候可能会需要返回指针指向的对象，比如（*this），这里存在的问题就在于编译器的转换策略，需要返回的是一个string对象，而你给它的是 *this，这个时候它就会自己创建一个stirng对象并且拷贝当前类的值（就是调用构造拷贝函数复制一下），而如果你返回一个char指针呢？它又会调用类的构造函数，C++的编译机制决定了它会尽量找到匹配的函数对变量进行转换

#ifndef CLASS_H
#define CLASS_H
#include<cstring>
using namespace std;
class String {
private:
      char *myStr;
      int myLen;
public:
    String(char *Str = NULL){
        if(Str){
            myLen=strlen(Str);
            myStr=new char[myLen+1];
            strcpy(myStr,Str);
        }
        else
            myStr = NULL;
    }
    // 复制构造函数
    String(const String &str){
        if (str.length()==0)
		{
			myLen=0;
			myStr=nullptr;
		}
		else
		{
			myStr=new char[str.myLen+1];
			strcpy(myStr,str.myStr);
		}
    }
    // 析构函数
    ~String(){
        if (myStr)
		    delete [] myStr;
	}
    // 0:获取字符串长度
    int length() const {
		return myLen;
	}
    // 1:求子字符串[start,end)
    String substr(int start, int end){
		String sub_str;
		sub_str.myStr=new char[end-start+1];
		int i;
		for (i=start;i<end;i++)
		{
			sub_str.myStr[i-start]=myStr[i];
		}
		sub_str.myStr[end-start]='\0';
		sub_str.myLen=end-start;

		return sub_str;
	}
     
    void printStr ()
	{
		for (int i=0;i<myLen;i++) printf("%c",myStr[i]);	
	}
};

#endif /* CLASS_H */

第四题

这个就是简单的多出一个符号的重载，注意下群里提到的头文件不要写函数的定义的问题即可，当然这个题目可以直接不在class.cpp里面引用头文件就是了

#ifndef CLASS_H
#define CLASS_H
#include<cstring>
#include <iostream>
using namespace std;
class String {
private:
      char *myStr;
      int myLen;
public:
    String(char *Str = NULL){
        if(Str){
            myLen=strlen(Str);
            myStr=new char[myLen+1];
            strcpy(myStr,Str);
        }
    }
    // 复制构造函数
    String(const String &str){
        if (str.length()==0)
        {
            myLen=0;
            myStr=nullptr;
        }
        else
        {
            myStr=new char[str.myLen+1];
            strcpy(myStr,str.myStr);
            myLen=str.myLen;
        }
    }
    // 析构函数
    ~String(){
        if (myStr)
            delete [] myStr;
    }
    // 0:获取字符串长度
    int length() const {
        return myLen;
    }
    // 1:求子字符串[start,end)
    String substr(int start, int end){
        String sub_str;
        sub_str.myStr=new char[end-start+1];
        int i;
        for (i=start;i<end;i++)
        {
            sub_str.myStr[i-start]=myStr[i];
        }
        sub_str.myStr[end-start]='\0';
        sub_str.myLen=end-start;
        return sub_str;
    }
    void printStr ()
    {
        for (int i=0;i<myLen;i++) printf("%c",myStr[i]);    
    }
    String& operator=(const String& s)
    {
        // if (myStr)
        //     delete [] myStr;
        myStr=new char[s.myLen+1];
        strcpy(myStr,s.myStr);
        myLen=s.myLen;
        return *this; 
    }
    friend ostream & operator<<(ostream& out,String &s);
};
ostream & operator<<(ostream& out,String &s){
    for (int i=0;i<s.myLen;i++) out<<s.myStr[i];
    return out;
}
#endif /* CLASS_H */