c++学习记录_02.05

学习内容

#include <iostream>
#include "stdlib.h"
#include "stdio.h"
using namespace std;

//命名空间的学习
namespace NAMESPACE
    { int a=0;
    namespace TEACHER
    {
        int age;
    }
    }

int main1()
{using namespace NAMESPACE;
using namespace NAMESPACE::TEACHER;
age=10;

    cout << age << endl;
    cout << "Hello world!" << endl;
    system("pause");
    return 0;
}

//register 寄存器关键字的增强，使数据存入寄存器中，速度变快，且c++中可以取寄存器地址
int main2()
{
    register int a=100;
    printf("%d\n",&a);
    system("pause");
    return 0;
}
//c++对二次定义变量的检测加强
int a=1;
//int a;
int main3()
{
    cout<<"会出错,这里就先屏蔽了"<<endl;
    system("pause");
    return 0;
}
//对struct的加强，c++里面认为struct就是对类型的定义，且struct和class完成的功能是一样的，但是只有class可以加函数？
struct A
{
    int a;
};
int main4()
{
    A a; //关键点在这
    a.a=10;
    cout<<a.a<<endl;
    system("pause");
    return 0;
}
//c++对变量类型和参数类型严格检测，不允许默认类型
/* int a(i)
    {
        cout<<"会出错"<<i<<endl;
        system ("pause");
        return 0;
    }
*/
int main5()
{

    int c=0;
   // a(c);
    system ("pause");
    return 0;
}
//c++新增bool类型，值只能为1和0；
int main6()
{
    bool b=true;
    bool b1=false;
    cout<<sizeof(bool)<<endl;
    cout<<b<<endl;
    system("pause");
    return 0;
}
//c++的三目运算符的增强
int main7()
{
    int a,b,c;
    a=10;
    b=20;
    (a>=b?a:b)=c;//c++里面允许三目运算符出现在赋值语句的左侧，因为c++返回的是变量的本身，而c返回的是变量的值
                //
    cout<<c<<endl;
    system("pause");
    return 0;
}
// const的使用检测
int main8()
{
    int t; //不允许常量定义整形？
    int   w;

    const int *q; //数据只读
    int const *r;
    // const int * const y;//不允许都只读？？
    system("pouse");
    return 0;
}
//结构体指针做函数参数
struct B
{
    int age;
};
int get_a(B *a)
{
    cout<<a->age<<endl;
    return 0;
}
int main9()
{
    B a;
    a.age=1;
    B *b;
    b=&a;
    get_a(b);
    system ("pause");
    return 0;
}
//const在c++中是一个真正的常量
int main10()
{
    const int a=10;
    const int *p;
    p=&a;  //会为p分配一个空间？貌似现在不行了？？
    //*p=20;//因为只读，所以不能赋值
    cout<<a<<endl;
    system("pause");
    return 0;

}
//const和define有相同之处，也有不同之处
//define只是单纯的文本替换，const有类型检查
int main11()
{
    #define a 10
    const int b=20; //const作用域比较广
    #undef a//使宏定义作用域局限

}
//引用语法
//引用语法的普通使用 取变量别名
int copy1 (int &a,int &b)//引用作为函数参数的时候不需要初始化
{
    b=a;
    cout<<b<<endl;
    return 0;
}
int main12()
{
int a=10,c=0;
int &b=a;   //引用c++的概念，在c中不存在 且不表示地址？ 普通的引用必须要初始化
cout<<b<<endl;
//引用作为函数参数的时候不需要初始化
copy1(a,c);
system("pause");
return 0;
}
//复杂数据类型引用做函数参数
struct TEACHER
{
    char name[6];
    int age;

};
int printtea(TEACHER &a)
{
    //./cout<<a.name<<endl;
    cout<<a.age<<endl;
    a.age=10;
    return 0;
}
int main13()
{
    TEACHER t;

    t.age=13;

    printtea(t);
    cout<<t.age<<endl;//通过函数传递的别名进行函数值的改变，指针也能完成相同功能
    system("pause");
    return 0;
}
//引用的本质
//1 引用就是同一段内存的门牌号
//2 普通引用有自己的内存，实现普通引用不初始化可以用结构
//3 引用是本质是一个常量指针，作为参数传递的时候是系统定义直接帮程序员把指针变量中的取地址的操作给做了
int mian14()
{
return 0;
}
//引用作为函数返回值
//返回变量的值
int geta1()
{
    int a;
    a=10;
    return a;
}
//返回引用的本身 就是引用的一个符本，返回的是值，用变量去接不会出错
//返回变量本身
int& geta2()
{
    int a;
    static int c;// 作全局变量后，返回值可以做左值
    a=10;
    return a; //如果返回栈上，也就是拿另一个引用取接，则可能会出错
                //如果返回的引用的引用本身的变量是静态变量或全局变量，也就是加static,则可以传递给另一个引用
}

int* geta3()
{
    int a;
    a=10;
    return &a;
}


int main()
{
    int&a=geta2();//不能作为引用的初始化，因为返回值的类型是引用
    system("pause");
    return 0;
}

#include
#include “stdlib.h”
#include “stdio.h”
using namespace std;

//命名空间的学习
namespace NAMESPACE
{ int a=0;
namespace TEACHER
{
int age;
}
}

int main1()
{using namespace NAMESPACE;
using namespace NAMESPACE::TEACHER;
age=10;

cout << age << endl;
cout << "Hello world!" << endl;
system("pause");
return 0;

}

//register 寄存器关键字的增强，使数据存入寄存器中，速度变快，且c++中可以取寄存器地址
int main2()
{
register int a=100;
printf("%d\n",&a);
system(“pause”);
return 0;
}
//c++对二次定义变量的检测加强
int a=1;
//int a;
int main3()
{
cout<<“会出错,这里就先屏蔽了”<<endl;
system(“pause”);
return 0;
}
//对struct的加强，c++里面认为struct就是对类型的定义，且struct和class完成的功能是一样的，但是只有class可以加函数？
struct A
{
int a;
};
int main4()
{
A a; //关键点在这
a.a=10;
cout<<a.a<<endl;
system(“pause”);
return 0;
}
//c++对变量类型和参数类型严格检测，不允许默认类型
/* int a(i)
{
cout<<“会出错”<<i<<endl;
system (“pause”);
return 0;
}
*/
int main5()
{

int c=0;

// a©;
system (“pause”);
return 0;
}
//c++新增bool类型，值只能为1和0；
int main6()
{
bool b=true;
bool b1=false;
cout<<sizeof(bool)<<endl;
cout<<b<<endl;
system(“pause”);
return 0;
}
//c++的三目运算符的增强
int main7()
{
int a,b,c;
a=10;
b=20;
(a>=b?a:b)=c;//c++里面允许三目运算符出现在赋值语句的左侧，因为c++返回的是变量的本身，而c返回的是变量的值
//
cout<<c<<endl;
system(“pause”);
return 0;
}
// const的使用检测
int main8()
{
int t; //不允许常量定义整形？
int w;

const int *q; //数据只读
int const *r;
// const int * const y;//不允许都只读？？
system("pouse");
return 0;

}
//结构体指针做函数参数
struct B
{
int age;
};
int get_a(B *a)
{
cout<age<<endl;
return 0;
}
int main9()
{
B a;
a.age=1;
B *b;
b=&a;
get_a(b);
system (“pause”);
return 0;
}
//const在c++中是一个真正的常量
int main10()
{
const int a=10;
const int *p;
p=&a; //会为p分配一个空间？貌似现在不行了？？
//*p=20;//因为只读，所以不能赋值
cout<<a<<endl;
system(“pause”);
return 0;

}
//const和define有相同之处，也有不同之处
//define只是单纯的文本替换，const有类型检查
int main11()
{
#define a 10
const int b=20; //const作用域比较广
#undef a//使宏定义作用域局限

}
//引用语法
//引用语法的普通使用 取变量别名
int copy1 (int &a,int &b)//引用作为函数参数的时候不需要初始化
{
b=a;
cout<<b<<endl;
return 0;
}
int main12()
{
int a=10,c=0;
int &b=a; //引用c++的概念，在c中不存在 且不表示地址？ 普通的引用必须要初始化
cout<<b<<endl;
//引用作为函数参数的时候不需要初始化
copy1(a,c);
system(“pause”);
return 0;
}
//复杂数据类型引用做函数参数
struct TEACHER
{
char name[6];
int age;

};
int printtea(TEACHER &a)
{
//./cout<<a.name<<endl;
cout<<a.age<<endl;
a.age=10;
return 0;
}
int main13()
{
TEACHER t;

t.age=13;

printtea(t);
cout<<t.age<<endl;//通过函数传递的别名进行函数值的改变，指针也能完成相同功能
system("pause");
return 0;

}
//引用的本质
//1 引用就是同一段内存的门牌号
//2 普通引用有自己的内存，实现普通引用不初始化可以用结构
//3 引用是本质是一个常量指针，作为参数传递的时候是系统定义直接帮程序员把指针变量中的取地址的操作给做了
int mian14()
{
return 0;
}
//引用作为函数返回值
//返回变量的值
int geta1()
{
int a;
a=10;
return a;
}
//返回引用的本身 就是引用的一个符本，返回的是值，用变量去接不会出错
//返回变量本身
int& geta2()
{
int a;
static int c;// 作全局变量后，返回值可以做左值
a=10;
return a; //如果返回栈上，也就是拿另一个引用取接，则可能会出错
//如果返回的引用的引用本身的变量是静态变量或全局变量，也就是加static,则可以传递给另一个引用
}

int* geta3()
{
int a;
a=10;
return &a;
}

int main()
{
int&a=geta2();//不能作为引用的初始化，因为返回值的类型是引用
system(“pause”);
return 0;
}