函数通过型参传递类的析构有关问题

函数通过型参传递类的析构问题
各位大牛，请教一个关于类作为型参传递进函数后析构与构造的问题：
//*****************************************************//
int _tmain(int argc, _TCHAR* argv[])
{
CTest TestClass;

GetClass(TestClass);
printf_s("%d",TestClass.nC);

return 0;
}
TestClass 是在_tmain函数中定义的，生命周期应该在整个_tmain函数中，
但是在调用GetClass函数后，并未重新生成一个CTest类型对象，而是直接
引用的TestClass，GetClass函数结束析构TestClass，而不是_tmain结束后
析构TestClass。
请问这是为什么！
//*****************************************************//

class CTest
{
public:
CTest()
{
nA=0;
nB=1;
nC=4;
lpszStr=(char **)malloc(sizeof(char *)*nC);
for (nA=0;nA<nC;nA++)
{
lpszStr[nA]=(char *)malloc(sizeof(char)*133);
sprintf_s(lpszStr[nA],133,"%d",nA);
}
}
~CTest()
{
nA=0;
nB=1;
nC=4;

for (nA=0;nA<nC;nA++)
{
free(lpszStr[nA]);
}
free(lpszStr);
}
char **lpszStr;
int nA;
int nB;
int nC;
};

int GetClass(CTest oldClass);

int _tmain(int argc, _TCHAR* argv[])
{
CTest TestClass;

GetClass(TestClass);
printf_s("%d",TestClass.nC);

return 0;
}

int GetClass(CTest oldClass)
{
return 0;
}

------解决方案--------------------

C/C++ code

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

class CTest
{
    public:
        CTest()
        {
            printf("in ctor\n");
            nA=0;
            nB=1;
            nC=4;
            lpszStr=(char **)malloc(sizeof(char *)*nC);
            for (nA=0;nA<nC;nA++)
            {
                lpszStr[nA]=(char *)malloc(sizeof(char)*133);
                snprintf(lpszStr[nA],133,"%d",nA);
            }
        }

        CTest(const CTest &e)
        {
            printf("in copy ctor\n");
            int index = 0;
            this->nA = e.nA;
            this->nB = e.nB;
            this->nC = e.nC;

            lpszStr=(char **)malloc(sizeof(char *)*nC);

            for( ; index < this->nC ; ++index )
            {
                lpszStr[index] = (char *)malloc(sizeof(char)*133);
                strncpy(lpszStr[index],e.lpszStr[index],133);
            }

        }

        CTest & operator=(const CTest &e)
        {
            int index = 0;
            if( this == &e)
            {
                return *this;
            }
            this->nA = e.nA;
            this->nB = e.nB;
            this->nC = e.nC;

            lpszStr=(char **)malloc(sizeof(char *)*nC);

            for(index = 0; index < this->nC; index++)
            {
                lpszStr[index] = (char *)malloc(sizeof(char)*133);
                strncpy(lpszStr[index],e.lpszStr[index],133);
            }
            
            return *this;
        }

        ~CTest()
        {
            char **pp = lpszStr;
            printf("in dector\n");

            for ( nA =0 ; nA < nC;nA++)
            {
                char *p = pp[nA];
                free(p);
                p = NULL;
            }
            free(pp);
            lpszStr = NULL;
        }


        char **lpszStr;
        int nA;
        int nB;
        int nC;
};

int GetClass(CTest oldClass);

int main(int argc, char * argv[])
{
    CTest TestClass;

    GetClass(TestClass);
//    printf("%d",TestClass.nC);

    return 0;
}

int GetClass(CTest oldClass)
{
    return 0;
}

函数通过型参传递类的析构有关问题

相关推荐