标签：std cout int namespace day1 using main
1. hello world
#include <iostream>
using namespace std;
int main() {
cout << "hello world"<<endl;
return 0;
}
2. C++对C的增强
方式一
#include <iostream>
using namespace std;
int main() {
int a;
cin >> a;
cout << "a=" << a << endl;
return 0;
}
方式二
#include <iostream>
int main(){
int a;
std::cin >> a;
std::cout << "a=" << a << std::endl;
return 0;
}
方式三
#include <iostream>
using std::cout;
using std::endl;
using std::cin;
int main(){
int a;
cin >> a;
cout << "a=" << a << endl;
return 0;
}
小结：
命名空间更好的控制标识符的作用域
cout代表黑屏幕，cin代表键盘
iostream提供一个叫命名空间的东西，标准的命名空间是std
1. 命名空间的普通定义
方式一
#include <iostream>
using namespace std;
namespace spaceA {
int g_a = 10;
}
int main() {
cout << spaceA::g_a << endl;
return 0;
}
方式二
#include <iostream>
using namespace std;
namespace spaceA {
int g_a = 10;
}
int main() {
using namespace spaceA;
cout << g_a << endl;
return 0;
}
方式三
#include <iostream>
using namespace std;
namespace spaceA {
int g_a = 10;
}
int main() {
using spaceA::g_a;
cout << g_a << endl;
return 0;
}
2. 命名空间的嵌套定义
方式一
#include <iostream>
using namespace std;
namespace spaceB {
int a = 20;
namespace spaceC {
struct teacher {
int id;
char name[64];
};
}
}
int main() {
using namespace spaceB::spaceC;
struct teacher t1;
t1.id = 10;
cout << "" << t1.id << endl;
return 0;
}
方式二
#include <iostream>
using namespace std;
namespace spaceB {
int a = 20;
namespace spaceC {
struct teacher {
int id;
char name[64];
};
}
}
int main() {
spaceB::spaceC::teacher t1;
t1.id = 10;
cout << "" << t1.id << endl;
return 0;
}
方式三
#include <iostream>
using namespace std;
namespace spaceB {
int a = 20;
namespace spaceC {
struct teacher {
int id;
char name[64];
};
}
}
int main() {
using spaceB::spaceC::teacher;
teacher t1;
t1.id = 10;
cout << "" << t1.id << endl;
return 0;
}
1. 定义函数时必须写明类型，即int不可省略
2. 声明结构体类型后，定义结构体变量时，C中需写struct，C++则不需要
3. 全局变量重定义的加强(随用随定义)
4. 布尔类型的增强
#include<iostream>
using namespace std;
int main() {
bool flag = true;
cout << "flag=" << flag << endl;
flag = false;
cout << "flag=" << flag << endl;
flag = 100;
cout << "flag=" << flag << endl;
return 0;
}
//bool类型的字节数为1
bool只能取0,1，非0自动转换为1，值只能为true和false
5. 三目运算符的增强
#include <iostream>
using namespace std;
int main() {
int a = 10,b = 20;
int c;
c = a < b ? a : b;
cout << "c=" << c << endl;
(a < b ? a : b) = 50;
//*((a < b) ? &a : &b) = 50;（C,C++通用写法）
cout << "a=" << a << endl;
return 0;
}
小结：
C++中三目运算符可以做左值，C中三目运算符不能做左值
C++中三目运算符返回变量自身，C中返回变量的值
C++中两种赋值同时出现时，不论谁前谁后，都是*((a < b) ? &a : &b) = 50的结果优先
6. const的增强
#include <iostream>
using namespace std;
int main() {
const int a = 10;
int* b = (int*)&a;
*b = 50;
//改变的为临时开辟的变量
cout << a << endl;
cout << *b << endl;
return 0;
}
C++中通过指针不能改变所指向常变量的值
C++中将const存于符号表中，无空间和地址
C++中const定义的为常量(与#define类似，但运行时段不同，define无法被输出)
7. 枚举类型的增强
#include <iostream>
using namespace std;
enum season {
SPR = 0,
SUM,
AUT,
WIN
};
int main() {
//enum season s=2;(×)
enum season s = AUT;
cout << s << endl;
return 0;
}
C++中枚举变量赋值只能赋左边的元素名，不能赋数字
3.C++对C的拓展
相对指针而提出，方便使用
1. 引用的基本使用
#include <iostream>
using namespace std;
int main() {
int a, b;
int* p = &a;
*p = 30;
p = &b;
*p = 20;
int& re = a;//int &使用引用数据类型，re就是a的别名
re = 50;
cout << "a=" << a << endl;
return 0;
}
小结：
引用可以理解为一个变量的别名
引用必须初始化,且不可改变，不存在空引用
可对引用，再次引用，多次引用的结果，是一个变量具有多个别名
符号前有数据类型时，是引用。其它皆为取址
2. 引用做函数的参数
#include <iostream>
using namespace std;
void change_value(int* p){
*p = 30;
}
void change_value2(int& p) {
p = 30;
}
int main() {
int a = 10;
cout << "a = " << a << endl;
change_value(&a);
a=10;
cout << "a = " << a << endl;
change_value2(a);
cout << "a = " << a << endl;
return 0;
}
//不用指针，直接改变，ar即代表a
#include <iostream>
using namespace std;
void swap(int* a,int *b){
int temp = *a;
*a = *b;
*b = temp;
}
void swap2(int& a,int& b){
int temp = a;
a = b;
b = temp;
}
int main(){
int a = 10;
int b = 20;
//swap(&a,&b);
swap2(a,b);
cout << "a = " << a << endl;
cout << "b = " << b << endl;
return 0;
}
引用声明与原有某一变量的关系。故而类型与原类型保持一致，且不分配内存，与被引用的变量有相同的地址
3. 引用关于结构体的使用
include <iostream>
using namespace std;
struct student{
int id;
char name[64];
};
void prints1(struct student s){
//student s=s1;结构体整个值拷贝，不建议使用
cout << s.id << "" << s.name << endl;
}
void prints2(struct student* s){
cout << s->id << "" <<s->name << endl;
}
void prints3(struct student& s){
//引用：student& s=s1;
cout << s.id << "" << s.name << endl;
}
int main(){
student s1={10,"zhang3"};
prints1(s1);
prints2(&s1);
prints3(s1);
return 0;
}
4. 引用的本质
#include <iostream>
using namespace std;
struct typeA {
int& a;
};
struct typeB {
int* a;
};
int main() {
cout << "sizeof(struct typeA)" << sizeof(struct typeA) << endl;
cout << "sizeof(struct typeB)" << sizeof(struct typeB) << endl;
return 0;
}
小结：
-
引用所占用的大小与指针是相等的
-
常量要初始化，引用也要初始化，引用可能是一种常量
综上两点，引用可能是一个常指针。引用在做函数参数时，与常指针的区别：调用时实参隐藏了&；引用操作赋值的时隐藏了*。
5. 引用作为函数的返回值（引用做左值）
#include <iostream>
using namespace std;
char* getmem(int num) {
char* p = NULL;
p = (char*)malloc(num);
return p;
}
int getmtm2(char** pp, int num) {
char* p = NULL;
p = (char*)malloc(num);
*pp = p;
return 0;
}
int getA1() {
int a = 10;
return a;
}
void getA2(int* a) {
*a = 10;
}
//引用作为返回值，不要返回局部变量的地址
int& getA3() {
int a = 10;
return a;
}
int& getA4() {
static int a = 10;
return a;
}
int main() {
int a = 0;
char* pp = NULL;
a = getA1();
pp = getmem(10);
int main_a = 0;
main_a = getA3();
cout << "main_a " << main_a << endl;
cout << "----------" << endl;
#if 0
int& main_a_re = getA3();
cout << "main_a_re " << main_a_re << endl;
cout << "main_a_re " << main_a_re << endl;
#endif
cout << "----------" << endl;
int& main_a_re = getA4();
cout << "main_a_re " << main_a_re << endl;
cout << "main_a_re " << main_a_re << endl;
//引用如果当函数返回值的话，函数可以当左值
getA4() = 1000;
return 0;
}
小结：
当函数返回值为引用时，如果返回值栈变量（局部变量），不能作为其它引用的初始值，不能作为左值使用
当函数返回值为引用时，若返回静态变量或全局变量，则可以做左值
6. 指针引用
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
struct teacher {
int id;
char name[64];
};
int get_mem(struct teacher** tpp) {
struct teacher* tp = NULL;
tp = (struct teacher*)malloc(sizeof(struct teacher));
if (tp == NULL) {
return -1;
}
tp->id = 100;
strcpy(tp->name, "li4");
*tpp = tp;
return 0;
}
int get_mem2(struct teacher*& tp) {
tp = (struct teacher*)malloc(sizeof(struct teacher));
if (tp == NULL) {
return -1;
}
tp->id = 300;
strcpy(tp->name, "wang5");
return 0;
}
void free_mem2(struct teacher*& tp) {
if (tp != NULL) {
free(tp);
tp = NULL;
}
}
void free_teacher(struct teacher** tpp) {
if (tpp == NULL) {
return;
}
struct teacher* tp = *tpp;
if (tp != NULL) {
free(tp);
*tpp = NULL;
}
}
int main() {
struct teacher* tp = NULL;
get_mem(&tp);
cout << "id=" << tp->id << ",name=" << tp->name << endl;
free_teacher(&tp);
cout << "---------------------" << endl;
get_mem2(tp);
cout << "id=" << tp->id << ",name=" << tp->name << endl;
free_mem2(tp);
return 0;
}
7. const引用
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
using namespace std;
int main() {
const int a = 10;
//如果想对一个常量进行引用，必须是一个const引用
const int& re = a;
int b = 20;
const int& re2 = b;
//相反如果一个普通变量，用一个const引用接收是可以的
//const int安全性较高,只可读
//此时不能通过re2改变b的值，但是b的值改变，re会随之改变
cout << "b = " << b << endl;
cout << "re2 = " << re2 << endl;
b = 30;
cout << "b = " << b << endl;
cout << "re2 = " << re2 << endl;
//b = 20 re2 = 20 b = 30 re2 = 30
return 0;
}
标签：std,cout,int,namespace,day1,using,main 来源： https://blog.csdn.net/weixin_51448937/article/details/113100021
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。