目录
1 关系
#include <iostream>
// 命名空间的引入方式
//引入命名空间的第一种方式
//第二种
using std::cout; //using 关键字 不是引入整个命名空间 而是引入命名空间一个变量
using std::endl;
//第三种
using namespace std; //using namespace 是引入整个命名空间
int aa;//是属于默认的全局作用域命名空间
//如何定义一个命名空间?
namespace namespaceA//定义一个命名空间 namespace是命名空间关键字类型， namespaceA 是命名空间的名字
{
// namespace A 空间领域
int a = 10;
int b = 20;
}
namespace namespaceB
{
int a = 20;
namespace namespaceC
{
struct teacher
{
int id;
char name[64];
};
}
namespace namespaceD
{
struct teacher
{
};
}
}
//使用自定义的命名空间
void test()
{
//using namespaceA::a;//真个test（）函数领域中所有的a 默认都是 namespaceA中的a
//using namespace namespaceA; //引入整个namespaceA空间
cout << "A::a = " << namespaceA::a << endl;
cout << "B::a = " << namespaceB::a << endl;
//cout << "a = " << a << endl;
//创建一个struct teacher的变量
//using namespace namespaceB::namespaceC;//把namepaceC中的所有定义的遍历都引入
//using namespaceB::namespaceC::teacher;
//namespaceB::namespaceC::teacher t;
using namespace namespaceB::namespaceC;
teacher t;
}
int main(void)
{
cout << "hello world" << endl;
//第一种使用命名空间变量的方式
std::cout << "你好" << std::endl;
test();
return 0;
}
c++对c的struct做了功能增强。
4 增强#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
struct teacher
{
int id;
char name[64];
};
//2 对全局变量的检测能力加强， 一个变量不管是声明，还是定义，只能出现一次
int g_val ; //全局变量
//int g_val = 10;// 右一个全局变量
//1 实用性的增强， 对于变量的定义的位置，可以随意，没有要求
int test1(void)
{
int i = 0;
for (i = 0; i < 10; i++)
{
}
for (int i = 0; i < 10; i++) {
}
return 0;
}
//2
void test2()
{
//teacher t1; //C++中 在使用struct 时候不需要再将 struct 写进来
}
//3
void f(int i)
{
cout << "i = " << i << endl;
}
//4 bool类型
void test3()
{
bool flag = true; //就代表逻辑真
flag = false; //就代表逻辑假
cout << "bool:sizeof() : " << sizeof(flag) << endl; //bool占一个字节。
flag = true; // 为真
cout << "flag = " << flag << endl; //当bool类型为true 他的数值是1
flag = false; //为假
cout << "flag = " << flag << endl;//当bool类型为false 他的数值是0
//flag = 10;
cout << "flag = " << flag << endl;
//flag = 100;
cout << "flag = " << flag << endl;
//flag = -100;
cout << "flag = " << flag << endl; //不管给bool赋值什么样的非0数值，他是都是true 1
//flag = 0;
cout << "flag = " << flag << endl;
//bool类型的取值，只有0 和1
if (flag == true) { //默认判断flag 是否为true
}
}
void test5()
{
int a = 10;
int b = 20;
(a < b ? a : b) = 30; //返回是a变量的别名
//a
cout << "a = " << a << endl;
(a < b ? 10 : b); //三木运算符 如果作为左值， 那么 返回的结果不能有常量
}
//c++对const的加强
void test6() {
const int a = 10; //c++的const 确实对a起了保护的作用，不能通过指针的间接赋值概念a的值
//
//int const b; //const int , int const 是等价的
int *p = (int*)&a; //当c++编译器 发现 对一个const的常量符号取地址，
*p = 20;//C语言中可以通过指针的间接赋值改变const变量
//*p 是改变的临时的变量 而不是 常量a符号
printf("a = %d\n", a);
}
#define A (3)
#define B (4)
void test7()
{
const int a = 3;
const int b = 4; //此时说明 c++中的const 就是一个常量， 永远不会被改变
//c++语言对const 的增强，将const 变量真正变成了常量
int array[a + b] = { 0 };
int array_2[A + B] = { 0 }; // define 和const 变量 在编译的阶段不一样， define是预处理器 const 是编译器
//#define ff (10)
const int ff = 10; //const 是编译器出 完全符合编译器的逻辑判断和此法分析
}
void test8()
{
//cout << "ff = " << ff << endl; //没有区域的划分
}
enum season {
SPR ,
SUM ,
AUT ,
WIN
};
void test9()
{
enum season s = SPR;
s = SUM; //为了增加枚举的可读性，
s = AUT;
s = WIN;
}
struct student
{
int id;
char name[64];
};
void change_stu(struct student *s)
{
s ->id = 10;
}
void change_stu2(const struct student *s)
{
//s->id = 10; //此时s所指向的区域是一个常量 不能够被修改
struct student s2;
s = &s2;
}
void change_stu3(struct student *const s)
{
s->id = 10;
//struct student s2;
//s = &s2; //s是一个常量指针
}
void change_stu4(const struct student *const s)
{
//s->id = 10;
//struct student s2;
//s = &s2; //s是一个常量指针
}
int g(int a, int b, int c)
{
return 100;
}
//函数一定要有返回值， 如过函数没有返回值，也要加void
int main(void)
{
//f(1, 2, 3); //error 对于函数传参的检测能力更加的严格，
//g(1, 2, 3); //C_++编译器 对函数形参传递 函数返回值 做了严格的检查
//test3();
//test5();
//test6();
test7();
test8();
return 0;
}
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
int g_val; //全局变量
int g_val = 10;// 右一个全局变量
typedef struct teacher
{
int id;
char name[64];
}teacher_t;
void f(int i)
{
printf("i = %d\n", i);
}
g()
{
return 10;
}
//3 C语言中的逻辑是与非
void test3()
{
int flag = 0; // C语言中 数值0表示为假
// int flag = 1; // C语言中 数值非0表示真 C语言中是通过数值是否为0 来分辨逻辑真假的。
}
//4 三目运算符的增强
void test4()
{
int a = 10;
int b = 20;
int min_value = 0;
//min_value = (a < b ? a : b);
//(a < b ? a : b) = 30;//返回的是一个数值， 10 ， 10 = 30
*(a < b ? &a : &b) = 30;
//*(a < b ? &10 : &b) = 30; //10 =30
printf("%d\n", a);
}
//5 c语言中的const
void test5()
{
const int a ;
//int const b; //const int , int const 是等价的
int *p = (int*)&a;
*p = 20;//C语言中可以通过指针的间接赋值改变const变量
printf("a = %d\n", a);
}
#define A (3)
#define B (4)
void test6()
{
int const a = 3;
int const b = 4; //再次说明 c语言中的 const 并不是一个常量，是一个变量 加了只读属性。
int array[A+ B] = { 0 }; //数组类型大小是固定， 将两个变量做长度，编译器无法确定长度
}
enum season {
SPR = 0,
SUM,
AUT,
WIN
};
void test7()
{
enum season s = SPR;
s = 0;
s = 1;
s = 2; // C语言对枚举类型的赋值， 是可以通过枚举的值，直接赋值的。
s = 136; //136 什么意思？
}
//1 实用性增强
int main(void)
{
//struct teacher t1; //在C语言中如果使用一个struct 复杂类型，那么必须将struct 关键字写进来
//teacher_t t2;
//printf("%d\n", g_val);
//f(1,2,3);//warning
//int value = 0;
//value = g(1, 2, 3, 4, 5);
//printf("%d\n", value);
//test4();
//test5();
test7();
return 0;
}
都是在编译阶段处理的
通过制裁宏定义限定宏定义的作用域。
