c++第一天笔记(上)

有关c与c++强类型与弱类型区别

void main1()
{
	//C++注重类型，强类型，严格检查类型
	int *p1=NULL;
	double *p2=NULL;
	//p1 = p2; 在C语言中合法,在c++中不合法,c++严格注重类型,C语言类型检查不明确


}

cpp独有的变量初始化与iostream实现输入与输出

       //int  a = 5;C语言和c++都可以这样
	//int a(5); c++独特的初始化方式
	//double a(3.5);
	//char *str = "1234";      

	//char *str("china"); 
	wchar_t *str(L"china");  //宽字符   

	//cout << str;//这样是输出str变量的地址
	//wcout << str;宽字符，汉字，棒子文
	system("pause");

注意:

cout是用来输出char的，如果用cout输出wchar，只会输出地址，要使用wcout输出wchar。

wcout默认是不输出中文的，要想输出中文，要先加入setlocale( LC_ALL, "chs" );这行代码。

c++要求

1.掌握各个知识点,并强化点与点之间的联系,

2.充分理解设计模式,

3.学会综合应用所有的知识点

c++与c头文件的不同

#include<iostream>//加以区分C++的头文件，还是C语言的头文件

在.cpp中用c的代码, c的头文件已经优化加了extern C使用c的调用与链接约定

c++独有的函数重载

:关于代理模式

重载函数是函数的一种特殊情况，为方便使用，C++允许在同一范围中声明几个功能类似的同名函数，但是这些同名函数的形式参数（指参数的个数或者类型或者类型顺序）不同,域返回值无关

//参数的个数，参数的类型不同，类型顺序不同, 与返回值无关
1.void go(int a)
2.void go(double a)//与1类型不同
3.void go(double a, int b)//与1,2参数个数不同
4.void go(int  a, double b)//与3个数类型而且类型顺序也不同
5.错误//*int go(double a)//参数与2相同不合法与返回值无关
void go(int a,int b)//与4的b的参数不同
上面1,2,3,5是合法的

c++独有函数默认参数

1.明确函数参数从右向左进行处理

2.默认参数必须右边,非默认参数必须左边(默认参数之间不能有非默认参数,)(非默认参数之间不能有默认参数)

3.函数重载冲突的解决办法:1.命名空间 2.用函数指针(注意:函数指针不可以有默认参数,需要精确调用)

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


//默认参数必须放在右边
//默认参数中间不允许出现不默认的

void print(int c, int a = 1, int d = 2, int b = 3)
{
	std::cout << "void print(int c,int a=1,int d=2,int b=3" << std::endl;
	std::cout << a << b << c << std::endl;
}

void print(double c)
{   std::cout << "void print(double c)" << std::endl;
	std::cout << c << std::endl;
}

void main()
{
   //print(1,2,3);
	//函数指针没有默认参数，必须全部输入数据
	//函数重载与函数默认参数冲突,需要你输入的参数类型不一个，个数不一样，顺序不一样不会出现问题，否则一定报错
	void(*pt1)(int c, int a, int d, int b) = print;
	//pt1(100, 1, 2, 3);//函数指针调用，没有用默认的

	print(100);//100是整数,这个会自动对应  void print(int c, int a = 1, int d = 2, int b = 3)
	print(100.0);//100.0是double类型这个将自动对应 void print(double c)

	system("pause");
}

最后c++独有的命名空间

输出符 <<
 命名空间 std
域控制符 ::

std::cout << "hello world";//输出hello world

namespace应用场合

1.瀑布迭代式软件开始

                                 1.数据重名

2.避免代码冲突       2.函数重名

                                   3.类和结构体重名

关于避免代码冲突的实例

<pre name="code" class="cpp">#include "iostream"  
//最近查看iostream时发现这个头文件包含了namespace std;这个命名空间
#include"stdlib.h"
namespace myspace//自定义的命名空间
{
	int a(15);//定义一个a的变量
    void  print() //在其空间定义一个函数
	{
		std::cout << "myspace" << std::endl;
	}

}

namespace myspaceA //自定义的命名空间
{
	int a(25);  //与上面定义的冲突,不过由于在不同的空间,木有事
	void  print()//与上面相同
	{
		std::cout << "myspaceA" << std::endl;
	}
}
::域操作符<pre name="code" class="cpp">void main1()
{ int a(5);//std::cout输出， <<输出符，根据类型泛型转换为字符串输出//std::endl;//换行，结束一个输出
std::cout << "myspace a=" << myspace::a << std::endl;
std::cout << "myspaceA a=" << myspaceA::a << std::endl;//std::cout << " main a=" << a << std::endl;
std::cout << "hello world" << std::endl; 
myspace::print();//调用不同命名空间的函数
myspaceA::print();//
system("pause");
}

另外namespace的例外,(命名空间匿名等价于命名空间默认为全局变量

#include"iostream"
//没有命名的命名空间可以直接调用
namespace
{
	int a(3);
	void print()
	{
		std::cout << "gogogo";
	}
}

void main3()
{

	std::cout << a;
	print();
}

命名空间特性

1.自己可以定义命名空间

2.可以自己拓展命名空间实现迭代

3.命名空间可以实现别名

4.命名空间可以嵌套

5.命名空间默认都是共有的

6.命名空间内部不可以重名

7,命名空间不同,同名变量需要命名空间明确

#include <iostream>

namespace runrunrunrun  //命名一个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;

}

<pre name="code" class="cpp">#include <iostream>

namespace runmove
{
	int  y(5);
	int(*padd)(int, int);//函数指针接口 
     //private: 命名空间是透明的
	int  y1(5);
	class myclass
	{
	public://类默认是私有，实现封装
		int a;
	};
}
//下面定义了2个函数,函数类型相同,一般不在命名空间内部定义函数,因为一旦这个空间需要改,那么很麻烦
//我们可以在命名空间内部定义一个函数指针实现接口封装,这样就易于维护

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;
}

7.命名空间不同,同名变量需要命名空间明确与using作用域
namespace mydata
{
	int a(6);
}
namespace yourdata
{
	int a(8);
}
using namespace mydata;//using必须在命名空间的后面，作用域,如果提前,会报错
using namespace yourdata;
//using如果变量重名，会出现不明确错误，加上命名空间修饰符
void go()
{

	//命名空间如果在块语句内容，作用域是定义开始到块语句结束
       //比如在这个块语句内部定义using namespace mydata,那么作用域就只有这个块语句
	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");
}

8;关于::其作用(引用全局命名空间,或者引用特定命名空间(解决特殊的C语言无法引用全局变量(下面定义了2个文件)

extern.c只有一条代码

static  int a = 10;

这是下一个文件代码

#include<iostream>//C++没有.h加以区分C/C++
//C/C++头文件  有没有命名空间
#include<stdlib.h>
//int a = 1;
extern  int a;//C++要求严格   //而如果是c语言,无需要再extern 默认是extern,而c++很严格
void main()
{
	int a = 3;   
	std::cout << ::a;//::这样就表示了是输出全局变量a (1)而不是3  
    //上面这句,c语言无法输出1,因为int a=3屏蔽了int a=1;这全局变量

	system("pause");
}

C++独有的auto自动变量

1.自动获取类型,泛型设计思想

2.c++11新语法实现自动循环一维数组(循环必须是指针常量,数组)

#include<iostream>
#include<stdlib.h>
//自动变量,自动获取类型,输出,泛型
//自动变量,可以实现自动循环一维数组
//自动循环的时候对应的必须是常量(如一维数组的数组名,或者2,3,4维的数组名)
void mai1111n()
{

	auto num = 10.9;//自动匹配类型
	auto numA = 10/2.0;//在c中无法获取auto的类型,c++可以
	std::cout << num <<std::endl<< numA << std::endl;
	system("pause");


}
void main()
{
	//int num[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	double num[10] = { 1.0, 2.0, 3.0, 4.5, 5, 6, 7, 8, 9, 10 };
	//auto可以实现很多类型体现了泛型编程
	//自动取出变量赋值给data    auto自动匹配
	for (auto data : num)   //auto实现通用(泛型c++语法)
	{
		std::cout << data<<std::endl;  
		
	}
	system("pause");






	/*double num[2][5] = { 1.0, 2.0, 3.0, 4.5, 5, 6, 7, 8, 9, 10 };//
	num此时是一个指针常量
	auto自动循环, begin   end;   必须是一个常量的数组
	for(auto data:num)这样将打印个数组
	
	自动取出变量赋值给auto data auto自动匹配
	for (auto data : num)   //auto实现通用(泛型c++语法)
	{     此时data是一个行指针
		std::cout << data << std::endl; //这里将打印地址
		for (int i = 0; i < 5; i++)//由于是指针,无法确定输出多少个,只好人工控制
		{             //*(data+i);
			std::cout << data[i] << std::endl;//输出元素
		}
	}*/
}