面试题

版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/sinat_33859977/article/details/88095289

1、

int main()
{
	int arr[] = {1,2,3,4,5,6,7};
	int *p = arr;
	*(p++) += 56;    //运算前p指向arr[0]被赋值57,运算后p指向arr[1]
	printf("%d,%d\n",*p,*(++p));   //运算前p执行++p指向arr[2],输出结果3,3
	return 0;
}

2、

class base
{
public:
    base(int i):b(i+1),a(b) {}
    int get_a(){return a;}
    int get_b(){return b;}
private:
    int a,b;

};

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    base obj(11);
    qDebug() << obj.get_a() << "  " << obj.get_b();//a:随机数 b:12
    return a.exec();
}

3、

class Base
{
public:
		char a;//字节对其占4个字节
		static char b;//静态全局区
		void *p;//指针占4个字节
		static int *c;//静态全局区
		virtual void func1();//虚函数指针占4个字节
		virtual void func2();//虚函数指针共用4字节空间
		int fun();//函数不占内存空间
}

sizeof(Base);//12字节

4、字符串逆序

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    char *src = "hello";
    char *dest = NULL;
    int len = strlen(src);
    dest = (char *)malloc(len);
    char *d = dest;
    char *s = src;
    s = s+len -1;
    while (len-- > 0) {
        *d = *s;
        d++;
        s--;
    }
    qDebug() << dest;

    return a.exec();
}

5、构造函数、析构函数和赋值函数的编写方法
已知类String的原型为:
class String
{
public:
String(const char *str = NULL); //普通构造函数
String(const String &other); //拷贝构造函数
~ String(void); //析构函数
String & operator =(const String &other); //赋值函数
private:
char *m_String; //私有成员,保存字符串
};
解析:
程序代码如下:

        #include <iostream>
        using namespace std;
        class String
        {
        public:
                String(const char *str = NULL);          //普通构造函数
                String(const String &other);             //拷贝构造函数
                ~ String(void);                         //析构函数
                String & operator =(const String &other);  //赋值函数
        private:
                char *m_String;    //私有成员,保存字符串
        };
        
        String::~String(void)             
        {
                cout << "Destructing"<< endl;
                if (m_String != NULL)                  //如果m_String不为NULL,释放堆内存
                {
                        delete [] m_String;
                        m_String = NULL;                //释放后置为NULL
                }
        }
        
        String::String(const char *str)      
        {
                cout << "Construcing" << endl; 
                if(str == NULL)                        //如果str为NULL,存空字符串""
                {
                        m_String = new char[1];            //分配一个字节
                        *m_String = '\0';                   //将之赋值为字符串结束符
                }     
                else
                {
                        m_String = new char[strlen(str) + 1]; //分配空间容纳str内容
                        strcpy(m_String, str);              //拷贝str到私有成员
                }
        }
        
        String::String(const String &other)  
        {
                cout << "Constructing Copy" << endl;
                m_String = new char[strlen(other.m_String) + 1];  //分配空间容纳str内容
                strcpy(m_String, other.m_String);               //拷贝str到私有成员
        }
        
        String & String:perator = (const String &other)   
        {
                cout << "Operate = Function" << endl; 
                if(this == &other)             //如果对象与other是同一个对象
                {                           //直接返回本身
                        return *this;
                }
                delete [] m_String;           //释放堆内存
                m_String = new char[strlen(other.m_String)+1];         
                strcpy(m_String, other.m_String);
        
                return *this;
        }
        
        int main()
        {
                String a("hello");            //调用普通构造函数
                String b("world");           //调用普通构造函数
                String c(a);                //调用拷贝构造函数
                c = b;                     //调用赋值函数
        
                return 0;
        }

(1)普通构造函数:这里判断了传入的参数是否为NULL。如果是NULL,初始化一个字节的空字符串(包括结束符’\0’);如果不是,分配足够大小长度的堆内存保存字符串。
(2)拷贝构造函数:只是分配足够小长度的堆内存保存字符串。
(3)析构函数:如果类私有成员m_String不为NULL,释放m_String指向的堆内存,并且为了避免产生野指针,将m_String赋为NULL。
(4)赋值函数:首先判断当前对象与引用传递对象是否是同一个对象,如果是,不做操作直接返回;否则先释放当前对象的堆内存,然后分配足够大小长度的堆内存拷贝字符串。
程序的执行结果如下:
Construcing
Construcing
Construcing Copy
Operate = Function
Destructing
Destructing
Destructing
这里代码第63~66行会发生构造函数以及赋值函数的调用,而析构函数的调用发生在main()函数退出时

展开阅读全文

没有更多推荐了,返回首页