c++Learning02

引用数组是不合法的，引用不是对象

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
////结构体的大小
//
////struct myStr {
//////    int c;
//////    double a;
//////    char b;    24
////
////    double a;
////    char b;
////    int c;//     16
////    void go(){
////        cout<<'h'<<endl;
////    };
////};
////
//////结构体的存储分配
////
////
//////如果sizeof一个引用，这个sizeof直接作用于引用的对象
////
////
////
////struct myStr1 {
//////    int c;
//////    double a;
//////    char b;    24
////
//////    double & a;
//////    char  & b;
////    int  & c;//     16
////    void go(){
////        cout<<'h'<<endl;
////    };
////};
//////sizeof类中的引用时,是指针的值(64位是8)
////int main(){
////    cout<< sizeof(myStr1)<<endl;        //8
////    int a = 10;
////    int &ra = a;
////    cout<< sizeof(ra)<<endl;            //4
////
////    return 0;
////}
//
////大小是8，因为函数储存在代码区,不计入sizeof
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
////newdelete全局重载
//
//
////在维护大型项目中需要
////局部new其实还是调用了全局new,分配内存还是全局new完成
////类内部的new没有完成分配内存的工作,只是做了一个劫持
//
////class MyClass{
////
////};
////int main(){
////    cout<<"size of myclass: "<< sizeof(MyClass)<<endl;
////    //sizeof(MyClass) 1,表明存在
////    return 0;
////}
////空类占一个字节
//
//
////class MyClass{
////    int a;
////};
////int main(){
////    cout<<"size of myclass: "<< sizeof(MyClass)<<endl;
////    //sizeof(MyClass) 4
////    return 0;
////}
//
////class MyClass{
////    int a;
////    MyClass(){
////        a = 10;
////    }
////};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
////void *operator new (size_t size){
////    cout<<"全局new重载"<<endl;
////    if(size == 0){
////        return 0;
////    }
////    void *p = malloc(size);
////    return p;
////}
////
////void operator delete(void * p){
////    cout<<"全局delete重载"<<endl;
////    free(p);
////}
////
////int main(){
////    int * p = new int(4);
////    delete p;
//////    MyClass * CC = new MyClass();
////    return 0;
////}
//
////创建的时候是局部new---全局new---malloc---调用构造函数
////销毁的时候是
//
//
//class tansheng {
//public:
//    int *p;
//    int length;
//public:
//    tansheng()//构建的时候初始化
//    {
//        std::cout << "构造函数谭胜被创建" << std::endl;
//    }
//
//    ~tansheng()//删除的时候释放内存
//    {
//        std::cout << "析构函数谭胜被销毁" << std::endl;
//    }
//
//    static void *operator new(size_t size) {
//        std::cout << "局部new0" << std::endl;
//        tansheng *ptemp = ::new tansheng;//劫持
//        std::cout << "局部new1" << std::endl;
//        return ptemp;
//    }
//    static void operator delete(void *p) {
//        std::cout << "局部delete" << std::endl;
//        ::delete p;//::全局
//    }
//
//
//    //添加局部new用于数组上
//    static void *operator new[](size_t size) {
//        std::cout << "局部数组new0" << std::endl;
//        void * p = operator new(size);
//        std::cout << "局部数组new1" << std::endl;
//        return p;
//    }
//    static void operator delete[](void *p) {
//        std::cout << "局部数组delete" << std::endl;
//        return operator delete(p);
//    }
//};
//
//void *operator new (size_t size){
//    cout<<"全局new"<<endl;
//    if(size == 0){
//        return 0;
//    }
//    void *p = malloc(size);
//    return p;
//}
//
//void operator delete(void * p){
//    cout<<"全局delete"<<endl;
//    free(p);
//}
//
//int main2(){
//
//
//    tansheng * p = new tansheng();
//
//
//
//    delete(p);
//    return 0;
//}
//
///*
// *
//局部new对象被创建0
//全局new重载
//构造函数谭胜被创建
//局部new对象被创建1
//构造函数谭胜被创建
//析构函数谭胜被销毁
//局部delete对象被销毁
//全局delete重载
// *
// *
// * */
////构造函数谭胜被创建 有两次为什么
//
//
////全局的new 和delete监视所有的
//
//
////如果是数组,全局重载
//
//void *operator new[](size_t size){
//    cout<<"数组全局new"<<endl;
//    return operator new (size);//每个对象挨个调用
//}
//void operator delete[](void*p){
//    cout<<"数组全局delete"<<endl;
//    return operator delete(p);//每个对象挨个调用已经重载好的delete
//}
//int main3(){
//
//    tansheng * p = new tansheng[5];
////    tansheng * p1 = new tansheng[5]();是什么意思?
//
//
//    delete []p;
////    delete p;//对于基本类型可以这样,但是非基本类型不可以
//
//}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
////大数乘法与结构体
//
//
//
////C语言结构体和C++结构体的区别
//
//
//
struct MyStruct1 {
    int num1;
    int num2;

    void gogo() {

    }
};

//可以继承
//可以有权限控制
//
int main66() {
//    MyStruct1 s1;
//    struct MyStruct1 ss;
    //有没有struct
    return 0;
}



//函数模板以及自动数据类型


//T是通用数据类型
template<typename T>
T Max(T *p, const int n) {
    T maxdata(p[0]);
    for (int i = 0; i < n; ++i) {
        if (maxdata < p[i]) {
            maxdata = p[i];
        }
    }
    return maxdata;
}


//int getAll(int n,...){
//
//}


//处理可变长参数需要使用
#include <iostream>
#include "cstdarg"
template<typename NT>
//参数至少要有一个是模板类型?
//NT date1没有什么用处就是做一个标志
NT sum(int num,NT date1,...) {
    va_list arg_ptr;//参数列表指针
    va_start(arg_ptr,num);//限定从num开始,限定多少个参数
    NT sumres(0);
    for (int i = 0; i < num; ++i) {
        sumres+=va_arg(arg_ptr,NT);
    }
    va_end(arg_ptr);//结束
    return sumres;
}

int main32() {
    std::cout<<sum<int>(5,1,2,3,4,5)<<std::endl;
    std::cout<<sum<double>(5,1.2,2.2,3.2,4.2,5.3)<<std::endl;

}


//auto与函数模板

//函数参数不能使用auto,而
//auto get(int data,double bigdata)-> decltype(data*bigdata){
//
//}



//自动数据类型,根据实际推导出类型
template<class T1, class T2>//根据类型获取类型
auto get(T1 t1, T2 t2) -> decltype(t1 * t2) {

};


//宽字符
//本地
#include "locale"
int main12312(){
    setlocale(LC_ALL,"chs");//设置本地化
    wchar_t  *p = L"123456";
    wchar_t  *p1 = L"你好23456";
    std::wcout<<p<<std::endl;
    std::wcout<<p1<<std::endl;


    return 1;
}

//inline函数
//和define效果一样
//但是define无法保证类型安全

#include "iostream"
#define GETX3(N) N*N*N
//内联函数,会在内部展开,相对于define类型安全
inline int getx3(int n){
    return n*n*n;
}

//inline使用模板化
template<typename T>
inline T getX2(T t) {//类型不匹配会出错,不是单纯的替换
    return t * t;
}

//inline只是对编译器的建议
/*
 * 一般情况下我们队内联函数做出以下限制
 * 不能有递归
 * 不能包含静态数据
 * 不能包含循环
 * 不包含数组
 * 不包含goto和switch
 *若一个内联函数不满足以上限制,编译器会把它当做普通函数
 *
 *
 *
 *
 * */
//
//int main(){
//    std::cout<<GETX3(1+2)<<std::endl;
//    //7------1+2*1+2*1+2
//    return 1;
//}





//c和c++的不同

/*
 * 常量表示方法不同
C 语言不支持引用的概念，而 C++支持
 注释不同，C89 不支持单行注释
 （++i) ++在 C 中不合法
 （a=3) =4 在 C 中不合法,而在这种情况下c++会将(a=3)转换成左值 a=4 c++检测右值在内存中有实体,会自动转换成左值.c语言不会把左值转换为右值

 不能在 for 循环头部定义变量
 *
 *
 *
 * */



//c语言中全局变量有声明和定义之间的区别

//c++中这样是错误的,全局变量没有声明的定义之间的区别
//int c;
//int c;
//int c;

//static全局变量
//c语言可以,c++错误
//静态全局变量没有声明的定义之间的区别
//static int vv;
//static int vv;


//因为c++是强类型的,所以函数返回值必须要有类型main()

int main2222(){
    int  a =3;
    (++a)++;
//    (a+1)++; a+1在内存中没有实体 在寄存器中计算出来
    return 0;
}

//寄存器变量
int main33(){
    register int a(10);
    //register做了优化,其实也是建议,可以取地址
    //c中是不行的
    std::cout<<&a<<std::endl;
}

//c++编译器的宽泛,c中就不可以
//为了修改源代码,后面留下拓展
//占位
void test(int a , double, double){

}


//delete以后尽量设置为NULL
int main(){
    int *p = new int(5);
//    delete p;
//    p = NULL;防止重复删除
//    delete p;
    return 1;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
//
// Created by 李克兢 on 2018/6/11.
//
#include <stdio.h>
#include "stdlib.h"
#include "string.h"

//初始化的时候必须这样,加上关键字
//结构体成员不能有函数
//没有公有私有
//没有继承
struct MyStruct {
    int num1;
    int num2;
};
//有小数该如何处理呢
//除法如何处理呢



//getBigData有点小问题
void getBigData(char *dataa, char *datab) {
    int lengthA = strlen(dataa);
    int lengthB = strlen(datab);
    int *pres = (int *) malloc(sizeof(int) * (lengthA + lengthB));
    /*初始化数组*/
    int lengthR = lengthA + lengthB;
//    for (int i = 0; i < lengthR; ++i) {
//        pres[i] = 0;
//    }
    memset(pres, 0, sizeof(int) * (lengthA + lengthB));
    //实现了累乘
    for (int i = 0; i < lengthA; ++i) {
        for (int j = 0; j < lengthB; ++j) {
            //预留一位
            pres[i + j + 1] += (dataa[i] = '0') * (dataa[j] = '0');
        }
    }
    //进位
    for (int k = lengthR - 1; k > 0; --k) {
        if (pres[k] > 10) {
            pres[k] %= 10;
            pres[k - 1] += pres[k] / 10;
        }
    }
    //打印
    int i = 0;
    while(pres[i] == 0){
        i++;
    }
    char * cres = (char*)malloc(sizeof(char)*(lengthR));
    int l;
    for (l= 0; l < lengthR; ++l) {
        cres[l] = pres[i] +'0';
        i++;
    }
    cres[l] = '\0';

    printf("打印:%s\n",cres);
//    for (int l = 0; l < strlen(cres); ++l) {
//        printf("%s",cres[l]);
//    }
}

int main22() {
//    struct MyStruct st;
    char str1[100] = {0};
    //    char str1 [100] = {0};初始化?
    char str2[100] = {0};
    scanf("%s%s", &str1, &str2);
    printf("%s\n", str1);
    printf("%s\n", str2);
    getBigData(str1,str2);
    printf("over11");
    return 0;
}