C与CPP不同以及命名空间简介
命名空间在软件设计中的作用就是为了实现迭代式开发。
命名空间的别名
#include <iostream>
namespace runrunrunrun
{
int a(10);
char *str("gogogo");
namespace run //命名空间的嵌套
{
int a(9);
}
}
namespace runrunrunrun //命名空间的拓展
{
int y(5);
//int a(15);重定义错误
}
namespace r = runrunrunrun;//给命名空间起一个别名
void main132()
{
std::cout << r::run::a << std::endl;//命名空间可以嵌套
std::cout << r::y << std::endl;
std::cout << r::a << std::endl;
}
//using namespace r;
void main11()
{
//std::cout << r::a <<r::str<< std::endl;
//std::cout << a << str << std::endl;
}
命名空间软件开发注意事项
#include <iostream>
namespace runmove
{
int y(5);
int(*padd)(int, int);//函数指针接口
//private: 命名空间是透明的
int y1(5);
class myclass
{
public://类默认是私有，实现封装
int a;
};
}
int add(int a, int b)
{
return a + b;
}
int addp(int a, int b)
{
std::cout << a << b;
return a + b;
}
struct MyStruct
{
int b;//结构体默认是透明的
private:
int a;//是私有
};
void main1123()
{
//namespace所有数据，函数，类，对象都是共有
MyStruct struct1;//结构体内部默认公有
struct1.b;
}
Using作用域
#include<iostream>
#include<stdlib.h>
namespace mydata
{
int a(6);
}
namespace yourdata
{
int a(8);
}
using namespace mydata;//using必须在命名空间的后面，作用域
using namespace yourdata;
//using如果变量重名，会出现不明确错误，加上命名空间修饰符
void go()
{
//命名空间如果在块语句内容，作用域是定义开始到块语句结束
std::cout << mydata::a << std::endl;
}
//using namespace mydata;//作用域为从代码开始到结束
void main()
{
//std::cout << mydata::a << std::endl;
std::cout <<yourdata::a << std::endl;
system("pause");
}
函数重载与函数默认参数
函数重载原理
#include<iostream>
#include<stdio.h>
//参数的个数，参数的类型不同，顺序不同,与返回值无关
void go(int a)
{
std::cout << a;
}
void go(double a)
{
std::cout << a;
}
void go(double a,int b )
{
std::cout << a << b;
}
void go(int a, double b)
{
std::cout << a << b;
}
//int go(double a)
//{
//
//
//}
//void go(int a,int b)
//{
//
//}
void main()
{
void(*pgo1)(int a)=go;
void(*pgo2)(double a)=go;
void(*pgo3)(double a, int b)=go;
void(*pgo4)(int a, double b)=go;
printf("%p\n",pgo1);
printf("%p\n", pgo2);
printf("%p\n", pgo3);
printf("%p\n", pgo4);
getchar();
}
默认参数
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
//默认参数必须放在右边,因为参数的入栈顺序是从右至左
//默认参数中间不允许出现不默认的
void print(int c,int a = 1, int d=2, int b = 3)
{
std::cout << a<<b<<c << std::endl;
}
void print(double c)
{
}
void main()
{
//print(1,2,3);
//函数指针没有默认参数，必须全部输入数据
//函数重载与函数默认参数冲突,需要你输入的参数类型不一个，个数不一样，顺序不一样不会出现问题，否则一定报错
void(*pt1)(int c, int a , int d , int b ) = print;
pt1(100,1,2,3);//函数指针调用，没有用默认的
print(100);
system("pause");
}
泛型auto
#include<iostream>
#include<stdlib.h>
//自动变量，自动获取类型，输出，泛型
//自动变量，可以实现自动循环一维数组
//自动循环的时候，对应的必须是常量
void main1()
{
auto num = 10.9;//自动变量，自动匹配类型
auto numA = 10/3.0;
std::cout << num <<" " << numA << std::endl;
system("pause");
}
void main()
{
//int num[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
double num[2][5] = { 1.0, 2.0, 3.0, 4.5, 5, 6, 7, 8, 9, 10 };
//num数组名是一个指针常量
//auto 自动循环 begin endl;，必须是一个数组的常量
//
for (auto data : num)//泛型C++语法,循环一维数组,常量
{
std::cout << data<<std::endl;
for (int i = 0; i < 5; i++)
{
std::cout << *(data + i) << std::endl;
}
}
system("pause");
}
Newdelete
对象数组
#include <iostream>
#include<stdlib.h>
class tansheng1
{
int *p;
int length;
public:
tansheng1()//构建的时候初始化
{
std::cout << "谭胜被创建1"<<std::endl;
}
~tansheng1()//删除的时候释放内存
{
std::cout << "谭胜被销毁1" << std::endl;
}
};
void main()
{
tansheng1 *p = new tansheng1[3];
delete []p;//基本数据类型，delete,复杂类型必须[]
system("pause");
}
New只能分配线程的内存
#include<stdio.h>
#include<stdlib.h>
#include<iostream>
void main1()
{
int num=10;//栈上
int *p = new int;//堆上
*p = 5;
std::cout << *p << " " << p << std::endl;
delete p;
// delete p;//只能释放一次
std::cout << p << std::endl;
system("pause");
}
void main2()
{
//int num[10];
int *p = new int[10];
//int i = 0;
std::cout << p << std::endl;
for (int i = 0; i < 10; i++)
{
p[i] = i;
std::cout << p[i] << std::endl;
}
delete []p;//删除数组的空间
std::cout << p << std::endl;
system("pause");
}
void main3()
{
int *p = new int[80];
int(*px)[10] = (int(*)[10]) p;
//int(*px)[10] = new int[80];new只能分配线性
int data = 0;
for (int i = 0; i < 8; i++)
{
for (int j = 0; j < 10; j++)
{
px[i][j] = data++;
std::cout << " " << px[i][j];
}
std::cout<<std::endl;
}
system("pause");
}
Newdelete重载
#include <iostream>
#include<stdlib.h>
class tansheng
{
public:
static int jishuqi;//静态
int *p;
int length;
public:
tansheng()//构建的时候初始化
{
std::cout << "谭胜被创建2" << std::endl;
}
~tansheng()//删除的时候释放内存
{
std::cout << "谭胜被销毁2" << std::endl;
}
static void * operator new(size_t size)
{
jishuqi += 1;
std::cout << "对象被创建2" << std::endl;
tansheng *ptemp = ::new tansheng;//劫持
return ptemp;
}
static void operator delete(void *p)
{
jishuqi -= 1;
std::cout << "对象被销毁2" << std::endl;
::delete p;//::全局
}
};
int tansheng::jishuqi = 0;
//类的内部的new没有完成分配内存的动作
//通往全局的new中间做了一个劫持
//空类占一个字节，表示自己存在
//类的对象，数据是独立，代码是共享的
//没有分配内存，构造函数无意义
class MyClass
{
int num;
public:
MyClass();
~MyClass();
private:
};
MyClass::MyClass()
{
}
MyClass::~MyClass()
{
}
void main()
{
tansheng * p1 = new tansheng;
tansheng * p2 = new tansheng;
tansheng * p3 = new tansheng;
tansheng * p4 = new tansheng;
std::cout << p1 << p2 << std::endl;
delete p1;
delete p2;
std::cout << tansheng::jishuqi << std::endl;
std::cout <<"myclass size"<<sizeof(MyClass) << std::endl;
system("pause");
}
